wiz-frameworks/es/components/wizOssUpload/index.js

wizlong react framework

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * WizOssUpload 
 * @description oss上传
 * @author mll
 * @date 2020-04-01
 */
import React from 'react';
import { connect } from 'dva';
import { Upload } from 'antd';
import 'antd/es/style/themes/default.less';
import { component_tool, utils_tool } from '../../tool';
import { Base64 } from 'js-base64';
import { getCustomDirByType } from './utils';
import { WizContainer } from '../WizContainer';
var WizButton = component_tool.WizButton,
    Wizmessage = component_tool.Wizmessage,
    WizModal = component_tool.WizModal,
    WizSpin = component_tool.WizSpin;
var Session = utils_tool.Session,
    isType = utils_tool.isType;

import { ossFileUtils } from '../../utils';

export var isIE = function isIE() {
    return !!window.ActiveXObject || "ActiveXObject" in window;
};

var S3_MIN_PART_SIZE = 5 * 1024 * 1024; //S3上传要求除最后一片分片，其余分片至少不小于5MB

var WizOssUpload = function (_WizContainer) {
    _inherits(WizOssUpload, _WizContainer);

    function WizOssUpload(props) {
        _classCallCheck(this, WizOssUpload);

        var _this = _possibleConstructorReturn(this, (WizOssUpload.__proto__ || Object.getPrototypeOf(WizOssUpload)).call(this, props));

        _this.componentName = 'WizOssUpload';
        _this.progress = {};
        _this.onBreakpoint = new Map();

        _this._networkListerner = function () {
            networkListerner && networkListerner(function (e) {
                if (!e) {
                    _this.setState({ networkResume: true });
                } else if (e && _this.state['networkResume']) {
                    _this._getAli([], function (ossClient) {
                        Object.keys(_this.progress).forEach(function (key) {
                            var _this$progress$key = _this.progress[key],
                                file = _this$progress$key.file,
                                checkpoint = _this$progress$key.checkpoint;

                            _this._breakpoint({
                                file: file,
                                ossClient: ossClient,
                                checkpoint: checkpoint,
                                callback: function callback(e) {
                                    e && e.forEach(function (_e) {
                                        _this._callbackFiles(_e);
                                    });
                                }
                            });
                        });
                    });
                }
            });
        };

        _this._getAli = function () {
            var files = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
            var callback = arguments[1];

            _this.doAction({
                path: 'upload/getAliParam',
                payload: {
                    uploadWay: _this.state.uploadWay,
                    success: function success(e) {
                        callback && callback(e);
                    }
                },
                onError: function onError() {
                    var e = files;
                    e && e.forEach(function (_e) {
                        _this._onFileError(_e);
                    });
                }
            });
        };

        _this._linkFile = function (files, callback) {
            var _this$props = _this.props,
                uploadType = _this$props.uploadType,
                courseNumber = _this$props.courseNumber,
                version = _this$props.version,
                courseType = _this$props.courseType,
                accept = _this$props.accept;

            var _fs = [];
            files.forEach(function (file) {
                var fileType = '';
                if (file['type']) {
                    fileType = file['type'];
                } else if (file['name'] && file['name'].indexOf('.') !== -1) {
                    var type = file['name'].substring(file['name'].lastIndexOf('.')) || '';
                    if (type) {
                        if (accept) {
                            if (accept.indexOf(type) !== -1) {
                                fileType = type.substring(1);
                            }
                        } else {
                            fileType = type.substring(1);
                        }
                    }
                }
                _fs.push({
                    fileName: file['name'],
                    size: file['size'],
                    fileType: fileType,
                    uid: file['uid']
                });
            });
            var appName = getCustomDirByType(files[0]['type']);
            var year = new Date().getFullYear();
            var month = new Date().getMonth() + 1;
            if (month.toString().length == 1) {
                month = "0" + month;
            }
            var yearMonth = year + '/' + month;
            _this.doAction({
                path: 'upload/linkFile',
                payload: {
                    params: {
                        customDir: appName,
                        appName: constants.env.sys_upload_app_name || 'sgm-lms-web',
                        yearMonth: yearMonth,
                        files: _fs,
                        courseNumber: courseNumber,
                        version: version,
                        courseType: courseType
                    },
                    type: uploadType,
                    success: function success(e) {
                        callback && callback(e);
                    },
                    onError: function onError(e) {
                        e && e.forEach(function (_e) {
                            _this._onFileError(_e);
                        });
                    }
                }
            });
        };

        _this._backUp = function (fileIdList, callback) {
            _this.doAction({
                path: 'upload/backUp',
                payload: {
                    params: { fileIdList: fileIdList },
                    success: function success(e) {
                        callback && callback(e);
                    }
                }
            });
        };

        _this._uploadResult = function (tasks, urlMap, callback) {
            _this.doAction({
                path: 'upload/uploadResult',
                payload: {
                    tasks: tasks,
                    urlMap: urlMap,
                    success: function success(e) {
                        callback && callback(e);
                    }
                }
            });
        };

        _this.propsAndStateOnChange = {
            uploadingFile: _this._uploadingFile.bind(_this),
            value: _this._value.bind(_this)
        };

        _this._callbackFiles = function (e) {
            var onChange = _this.props.onChange;

            var fs = [];
            if (_this.state.fileList && _this.state.fileList.length) {
                _this.state.fileList.forEach(function (f) {
                    if (f['uid'] === e['uid']) {
                        fs.push(e);
                    } else {
                        fs.push(f);
                    }
                });
            } else {
                fs = e;
            }
            _this.setState({ fileList: fs }, function () {
                onChange && onChange(fs);
            });
        };

        _this.beforeUpload = function (file) {
            var beforeUpload = _this.props.beforeUpload;

            var uploadFile = function uploadFile(f) {
                _this._uploadFile([f], function (e) {
                    e && e.forEach(function (_e) {
                        _this._callbackFiles(_e);
                    });
                });
            };
            if (beforeUpload) {
                var r = beforeUpload && beforeUpload(file, function (_file) {
                    _file['uid'] = file['uid'];
                    uploadFile(_file);
                }, function () {
                    _this._onRemove(file);
                });
                if (r) {
                    uploadFile(file);
                }
            } else {
                uploadFile(file);
            }
            return false;
        };

        _this._onChange = function (_ref) {
            var file = _ref.file,
                fileList = _ref.fileList,
                event = _ref.event;

            if (file['status'] !== 'removed') {
                _this.setState({ uploadingFile: fileList });
            }
        };

        _this._onRemove = function (file) {
            var _this$props2 = _this.props,
                onRemove = _this$props2.onRemove,
                onChange = _this$props2.onChange,
                protect = _this$props2.protect;

            var r = true;
            if (onRemove) {
                r = onRemove && onRemove(file);
            }
            if (r) {
                if (protect && _this.progress[file['fileId']]) {
                    Wizmessage.error('文件正在上传中, 请等上传完成后进行操作');
                    return false;
                } else {
                    _this.removeFileId.push(file['fileId']);
                }
                var files = [];
                _this.state.fileList.forEach(function (f) {
                    if (file['uid'] !== f['uid']) {
                        files.push(f);
                    }
                });
                _this.setState({ fileList: files }, function () {
                    onChange && onChange(files);
                });
            }
            return true;
        };

        _this._onFileError = function (file) {
            var files = [];
            _this.state.fileList.forEach(function (f) {
                if (file['uid'] === f['uid']) {
                    var _f = _extends({}, f);
                    _f['status'] = 'c';
                    delete _f['url'];
                    delete _f['thumbUrl'];
                    files.push(_f);
                } else {
                    files.push(f);
                }
            });
            _this.setState({ fileList: files });
        };

        _this._uploadFile = function (files, callback) {
            var uidMap = new Map();
            if (!files || !files.length) {
                Wizmessage.error({ content: '选择文件错误,请重新选择!', key: 'oss_upload' });
                return;
            } else {
                files.forEach(function (_v) {
                    uidMap.set(_v['uid'], _v);
                });
            }
            Wizmessage.info({ content: '开始上传文件,请勿离开页面', key: 'oss_upload', duration: 5 });
            _this._linkFile(files, function (f) {
                var _files = [];
                if (isType(f, 'Array')) {
                    _files = f;
                } else {
                    _files.push(f);
                }
                _this._getAli(files, function (uploadClient) {
                    var simple = [];
                    var multipart = [];
                    var simpleS3 = [];
                    var multipartS3 = [];
                    _files.forEach(function (_f) {
                        if (_this.checkMultipart(_f)) {
                            if (_this.state.uploadWay === 'S3') {
                                multipartS3.push(_f);
                            } else {
                                multipart.push(_f);
                            }
                        } else {
                            if (_this.state.uploadWay === 'S3') {
                                simpleS3.push(_f);
                            } else {
                                simple.push(_f);
                            }
                        }
                    });
                    if (simpleS3.length) {
                        _this._uploadingS3({ _files: _files, callback: callback, uidMap: uidMap, S3Client: uploadClient, fileSources: files });
                    }
                    if (multipartS3.length) {
                        multipartS3.forEach(function (f) {
                            _this._multipartUploadS3({ file: f, callback: callback, S3Client: uploadClient, fileSources: files });
                        });
                    }
                    if (simple.length) {
                        _this._uploading({ _files: _files, callback: callback, uidMap: uidMap, ossClient: uploadClient });
                    } else if (multipart.length) {
                        multipart.forEach(function (m) {
                            _this._multipartUpload({ file: m, callback: callback, uidMap: uidMap, ossClient: uploadClient });
                        });
                    }
                });
            });
        };

        _this.checkMultipart = function (file) {
            var maxSize = _this.state.uploadWay === 'S3' ? S3_MIN_PART_SIZE : 1 * 1024 * 1024;
            if (file['size'] > maxSize) {
                return true;
            }
            return false;
        };

        _this._getBlob = function (fileSource, callback) {
            var reader = new FileReader();
            reader.readAsArrayBuffer(fileSource);
            var blob = null;
            reader.onload = function (e) {
                if (typeof e.target.result === 'object') {
                    blob = new Blob([e.target.result]);
                } else {
                    blob = e.target.result;
                }
                callback && callback(blob);
            };
        };

        _this._uploadingS3 = function (_ref2) {
            var _files = _ref2._files,
                callback = _ref2.callback,
                uidMap = _ref2.uidMap,
                S3Client = _ref2.S3Client,
                fileSources = _ref2.fileSources;

            var urlMap = new Map();

            var successFunc = function successFunc(successList) {
                var sText = void 0,
                    eText = void 0;
                var ids = [];
                successList.forEach(function (_uf) {
                    if (urlMap.has(_uf['sysUrl'])) {
                        if (sText) {
                            sText += '、' + _uf['fileOriginalName'];
                        } else {
                            sText = _uf['fileOriginalName'];
                        }
                        ids.push(_uf['fileId']);
                        urlMap['delete'](_uf['sysUrl']);
                    }
                });
                if (urlMap.size) {
                    var _iteratorNormalCompletion = true;
                    var _didIteratorError = false;
                    var _iteratorError = undefined;

                    try {
                        for (var _iterator = urlMap.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                            var value = _step.value;

                            if (eText) {
                                eText += '、' + value['fileOriginalName'];
                            } else {
                                eText = value['fileOriginalName'];
                            }
                            var eFile = uidMap.get(value['uid']);
                            eFile['status'] = 'error';
                            successList.push(eFile);
                        }
                    } catch (err) {
                        _didIteratorError = true;
                        _iteratorError = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion && _iterator['return']) {
                                _iterator['return']();
                            }
                        } finally {
                            if (_didIteratorError) {
                                throw _iteratorError;
                            }
                        }
                    }
                }
                if (successList.length && ids.length) {
                    _this._backUp(ids, function (e) {
                        if (e) {
                            sText && Wizmessage.success({ content: '\u6587\u4EF6 ' + sText + ' \u4E0A\u4F20\u6210\u529F', key: 'oss_upload' });
                            eText && Wizmessage.error({ content: '\u6587\u4EF6 ' + eText + ' \u4E0A\u4F20\u5931\u8D25', key: 'oss_upload_error' });
                            callback && callback(successList);
                        } else {
                            Wizmessage.error({ content: '\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25,\u8BF7\u7A0D\u540E\u5C1D\u8BD5', key: 'oss_upload' });
                            var failList = [];
                            ids.forEach(function (id) {
                                successList.forEach(function (file) {
                                    if (id === file['fileId']) {
                                        failList.push(file);
                                    }
                                });
                            });
                            failList.forEach(function (_failFile) {
                                _this._onFileError(file);
                            });
                        }
                    });
                }
            };

            _files.map(function (_file) {
                urlMap.set(_file['url'], _file);
                var fileSource = fileSources.filter(function (file) {
                    return file.uid && file.uid === _file.uid;
                })[0];
                _this._getBlob(fileSource, function (blob) {
                    var params = {
                        Key: _file['url'],
                        Bucket: 'smvic-lds',
                        ContentType: _file.fileType,
                        Body: blob,
                        'Access-Control-Allow-Credentials': '*',
                        'ACL': 'public-read'
                    };
                    S3Client.upload(params, function (err, data) {
                        var successFiles = [];
                        if (!err) {
                            var _sFile = _extends({}, _file);
                            var _url = ossFileUtils.getS3FileById(_file.fileId, _file.fileType);
                            _sFile['sysUrl'] = _sFile['url'];
                            _sFile['url'] = _url;
                            _sFile['thumbUrl'] = _url;
                            _sFile['status'] = 'done';
                            _sFile['percent'] = 100;
                            _sFile['name'] = _sFile['fileOriginalName'];
                            successFiles.push(_sFile);
                            successFunc(successFiles);
                        }
                    });
                });
            });
        };

        _this._multipartUploadS3 = function (_ref3) {
            var file = _ref3.file,
                callback = _ref3.callback,
                S3Client = _ref3.S3Client,
                fileSources = _ref3.fileSources;

            var multipartMap = {
                Parts: []
            };

            var fileKey = file['url'];
            var fileSource = fileSources.filter(function (f) {
                return f.uid && f.uid === file.uid;
            })[0];
            var multipartSuccess = _this._multipartS3OnSuccess;
            var multipartFail = _this._multipartOnError;
            _this._getBlob(fileSource, function (blob) {
                var multipartUploadParams = {
                    Key: fileKey,
                    Bucket: 'smvic-lds',
                    ContentType: file.fileType,
                    'ACL': 'public-read'
                };

                var startTime = new Date();

                S3Client.createMultipartUpload(multipartUploadParams, function (err, data) {
                    if (!err) {
                        // console.log('createMultipartUpload --> ', data)

                        var UploadId = data.UploadId;

                        var totalSize = blob.size;
                        var partSize = Math.max(constants.env.sys_S3_part_size || S3_MIN_PART_SIZE, S3_MIN_PART_SIZE);
                        var partTotal = Math.ceil(totalSize / partSize);
                        var partNumber = 0;
                        var completePartTotal = 0;

                        var completeMultipartUpload = function completeMultipartUpload(doneParams) {
                            S3Client.completeMultipartUpload(doneParams, function (completeErr, completeData) {
                                if (completeErr) {
                                    console.log('An error occurred while completing the multipart upload --> ', completeErr);
                                    multipartFail(file, callback, completeErr);
                                } else {
                                    var delta = (new Date() - startTime) / 1000;
                                    console.log('Completed upload in ', delta, ' seconds. ', 'Final upload data --> ', completeData);
                                    multipartSuccess(file, ossFileUtils.getS3FileById(file.fileId, file.fileType), callback);
                                }
                            });
                        };

                        var uploadPart = function uploadPart(partParams) {
                            var tryNum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

                            S3Client.uploadPart(partParams, function (partErr, partData) {
                                if (partErr) {
                                    console.log('upload part error:', partErr);
                                    if (tryNum < 3) {
                                        // console.log('Retrying upload of part: #', partParams.PartNumber)
                                        uploadPart(partParams, tryNum + 1);
                                    } else {
                                        // console.log('Failed uploading part: #', partParams.PartNumber)
                                    }
                                    return;
                                }
                                var currentNumber = Number(partParams.PartNumber);
                                // console.log('Completed part --> ', currentNumber)
                                // console.log('part data --> ', partData)
                                multipartMap.Parts[currentNumber - 1] = {
                                    ETag: partData.ETag,
                                    PartNumber: currentNumber
                                };
                                completePartTotal++;
                                if (partTotal > completePartTotal) return;

                                var doneParams = {
                                    Bucket: 'smvic-lds',
                                    Key: fileKey,
                                    MultipartUpload: multipartMap,
                                    UploadId: partParams.UploadId

                                    // console.log('Completing upload...')
                                };completeMultipartUpload(doneParams);
                            });
                        };

                        for (var start = 0; start < totalSize; start += partSize) {
                            partNumber++;
                            var end = Math.min(start + partSize, totalSize);
                            var partParams = {
                                Body: blob.slice(start, end),
                                Bucket: 'smvic-lds',
                                Key: fileKey,
                                PartNumber: String(partNumber),
                                UploadId: UploadId

                                // console.log('Uploading part: #', partParams.PartNumber, ', Range start:', start)
                            };uploadPart(partParams);
                        }
                    } else {
                        console.log('createMultipartUpload err --> ', err);
                    }
                });
            });
        };

        _this._multipartS3OnSuccess = function (file, S3Url, callback) {
            if (_this.removeFileId.indexOf(file['fileId']) !== -1) {
                return;
            }
            var _sFile = _extends({}, file);
            var url = S3Url;
            _sFile['sysUrl'] = _sFile['url'];
            _sFile['url'] = url;
            _sFile['thumbUrl'] = url;
            _sFile['status'] = 'done';
            _sFile['percent'] = 100;
            _sFile['name'] = _sFile['fileOriginalName'];
            _this._backUp([file['fileId']], function (e) {
                if (e) {
                    Wizmessage.success({ content: '\u6587\u4EF6 ' + _sFile['fileOriginalName'] + ' \u4E0A\u4F20\u6210\u529F', key: 'oss_upload' });
                    callback && callback([_sFile]);
                } else {
                    Wizmessage.error({ content: '\u6587\u4EF6' + _sFile['fileOriginalName'] + '\u4E0A\u4F20\u5931\u8D25,\u8BF7\u7A0D\u540E\u5C1D\u8BD5', key: 'oss_upload' });
                    _this._onFileError(file);
                }
            });
        };

        _this._uploading = function (_ref4) {
            var _files = _ref4._files,
                callback = _ref4.callback,
                uidMap = _ref4.uidMap,
                ossClient = _ref4.ossClient;

            var urlMap = new Map();
            var tasks = _files.map(function (_file) {
                urlMap.set(_file['url'], _file);
                return ossClient.put(_file['url'], uidMap.get(_file['uid']));
            });
            _this._uploadResult(tasks, urlMap, function (successList) {
                var sText = void 0,
                    eText = void 0;
                var ids = [];
                successList.forEach(function (_uf) {
                    if (urlMap.has(_uf['sysUrl'])) {
                        if (sText) {
                            sText += '、' + _uf['fileOriginalName'];
                        } else {
                            sText = _uf['fileOriginalName'];
                        }
                        ids.push(_uf['fileId']);
                        urlMap['delete'](_uf['sysUrl']);
                    }
                });
                if (urlMap.size) {
                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                        for (var _iterator2 = urlMap.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                            var value = _step2.value;

                            if (eText) {
                                eText += '、' + value['fileOriginalName'];
                            } else {
                                eText = value['fileOriginalName'];
                            }
                            var eFile = uidMap.get(value['uid']);
                            eFile['status'] = 'error';
                            successList.push(eFile);
                        }
                    } catch (err) {
                        _didIteratorError2 = true;
                        _iteratorError2 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion2 && _iterator2['return']) {
                                _iterator2['return']();
                            }
                        } finally {
                            if (_didIteratorError2) {
                                throw _iteratorError2;
                            }
                        }
                    }
                }
                if (successList.length && ids.length) {
                    _this._backUp(ids, function (e) {
                        if (e) {
                            sText && Wizmessage.success({ content: '\u6587\u4EF6 ' + sText + ' \u4E0A\u4F20\u6210\u529F', key: 'oss_upload' });
                            eText && Wizmessage.error({ content: '\u6587\u4EF6 ' + eText + ' \u4E0A\u4F20\u5931\u8D25', key: 'oss_upload_error' });
                            callback && callback(successList);
                        } else {
                            Wizmessage.error({ content: '\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25,\u8BF7\u7A0D\u540E\u5C1D\u8BD5', key: 'oss_upload' });
                            var failList = [];
                            ids.forEach(function (id) {
                                successList.forEach(function (file) {
                                    if (id === file['fileId']) {
                                        failList.push(file);
                                    }
                                });
                            });
                            failList.forEach(function (_failFile) {
                                _this._onFileError(file);
                            });
                        }
                    });
                }
            });
        };

        _this._multipartUpload = function (_ref5) {
            var file = _ref5.file,
                callback = _ref5.callback,
                uidMap = _ref5.uidMap,
                ossClient = _ref5.ossClient;

            _this.doAction({
                path: 'upload/multipartUpload',
                payload: {
                    ossClient: ossClient,
                    file: uidMap.get(file['uid']),
                    fileName: file['url'],
                    onProgress: function onProgress(percentage, checkpoint, res) {
                        _this._multipartOnProgress(file, ossClient, callback, { percentage: percentage, checkpoint: checkpoint, res: res });
                    },
                    onSuccess: function onSuccess(result) {
                        _this._multipartOnSuccess(file, callback, result);
                    },
                    onError: function onError(err) {
                        _this._multipartOnError(file, callback, err);
                    }
                }
            });
        };

        _this._breakpoint = function (_ref6) {
            var file = _ref6.file,
                ossClient = _ref6.ossClient,
                checkpoint = _ref6.checkpoint,
                callback = _ref6.callback;

            _this.onBreakpoint.set(file['fileId'], checkpoint);
            _this.doAction({
                path: 'upload/breakpoint',
                payload: {
                    ossClient: ossClient,
                    checkpoint: checkpoint,
                    onProgress: function onProgress(percentage, checkpoint, res) {
                        _this._multipartOnProgress(file, ossClient, callback, { percentage: percentage, checkpoint: checkpoint, res: res });
                    },
                    onSuccess: function onSuccess(result) {
                        _this._multipartOnSuccess(file, callback, result, function (fileId) {
                            _this.onBreakpoint['delete'](fileId);
                        });
                    },
                    onError: function onError(err) {
                        _this._multipartOnError(file, callback, err);
                    }
                }
            });
        };

        _this._multipartOnProgress = function (file, ossClient, callback, _ref7) {
            var percentage = _ref7.percentage,
                checkpoint = _ref7.checkpoint,
                res = _ref7.res;

            var _file = _extends({}, file);
            _file['name'] = file['fileOriginalName'];
            _file['percent'] = parseInt(percentage * 100);
            _file['status'] = 'uploading';
            _this.progress[file['fileId']] = { file: file, checkpoint: checkpoint };
            _this.checkAliOvertime(function (e) {
                if (_this.removeFileId.indexOf(file['fileId']) === -1) {
                    if (e && res['status'] === 200) {
                        callback && callback([_file]);
                    } else {
                        ossClient.cancel();
                        _this._getAli(file, function (o) {
                            _this._breakpoint({ file: file, ossClient: o, checkpoint: checkpoint, callback: callback });
                        });
                    }
                }
            });
        };

        _this.checkAliOvertime = function (cb) {
            _this.doAction({
                path: 'upload/checkAliOvertime',
                payload: {
                    callback: function callback(e) {
                        cb && cb(e);
                    }
                }
            });
        };

        _this._multipartOnSuccess = function (file, callback, result, breakpointCallback) {
            var r = result;
            if (_this.removeFileId.indexOf(file['fileId']) !== -1) {
                return;
            }
            if (r && r['res'] && r['res']['status'] === 200) {
                var _sFile = _extends({}, file);
                var url = ossFileUtils.getOssUrlBySuffix(_sFile['url']);
                _sFile['sysUrl'] = _sFile['url'];
                _sFile['url'] = url;
                _sFile['thumbUrl'] = url;
                _sFile['status'] = 'done';
                _sFile['percent'] = 100;
                _sFile['name'] = _sFile['fileOriginalName'];
                _this._backUp([file['fileId']], function (e) {
                    if (e) {
                        Wizmessage.success({ content: '\u6587\u4EF6 ' + _sFile['fileOriginalName'] + ' \u4E0A\u4F20\u6210\u529F', key: 'oss_upload' });
                        callback && callback([_sFile]);
                    } else {
                        Wizmessage.error({ content: '\u6587\u4EF6' + _sFile['fileOriginalName'] + '\u4E0A\u4F20\u5931\u8D25,\u8BF7\u7A0D\u540E\u5C1D\u8BD5', key: 'oss_upload' });
                        _this._onFileError(file);
                    }
                });
                delete _this.progress[file['fileId']];
                breakpointCallback && breakpointCallback(file['fileId']);
            } else {
                if (breakpointCallback) {
                    breakpointCallback();
                    Wizmessage.error({ content: '\u6587\u4EF6 ' + file['fileOriginalName'] + ' \u4E0A\u4F20\u5931\u8D25, \u8BF7\u7A0D\u540E\u518D\u8BD5', key: 'oss_upload_error' });
                    _this._onFileError(file);
                    breakpointCallback && breakpointCallback(file['fileId']);
                } else {
                    WizModal.confirm({
                        title: '文件上传失败',
                        content: '\u6587\u4EF6 ' + file['fileOriginalName'] + ' \u4E0A\u4F20\u5931\u8D25, \u662F\u5426\u5C1D\u8BD5\u91CD\u65B0\u4E0A\u4F20?',
                        onOk: function onOk() {
                            _this._getAli([file], function (ossClient) {
                                _this._breakpoint({ file: file, ossClient: ossClient, checkpoint: _this.progress[file['fileId']]['checkpoint'], callback: callback });
                            });
                        },
                        onCancel: function onCancel() {
                            _this._onFileError(file);
                        }
                    });
                }
            }
        };

        _this._multipartOnError = function (file, callback, err) {
            log.info('oss multipart upload fail:', err);
            //主动取消的不处理
            if (err && err['name'] === 'cancel') {
                return;
            }
            //去除上传队列
            if (_this.onBreakpoint.has(file['fileId'])) {
                _this.onBreakpoint['delete'](file['fileId']);
            }
            Wizmessage.error({ content: '\u6587\u4EF6 ' + file['fileOriginalName'] + ' \u4E0A\u4F20\u5931\u8D25, \u8BF7\u7A0D\u540E\u518D\u8BD5', key: 'oss_upload_error' });
            _this._onFileError(file);
        };

        var uploadWay = constants.env.sys_upload_way || 'Oss';
        if (_this.props.uploadWay) {
            uploadWay = _this.props.uploadWay;
        }
        _this.state = {
            fileList: _this.props.value ? _this.props.value : [],
            networkResume: false,
            loading: false,
            uploadWay: uploadWay
        };
        _this.removeFileId = [];
        return _this;
    }

    /**
     * 默认参数
     * 支持antd-upload的参数
     */


    /**
     * 分片上传 记录分片信息
     */


    /**
     * 断点续传 正在断点续传文件的队列
     */


    _createClass(WizOssUpload, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            var _this2 = this;

            var fileList = this.state.fileList;

            var fileIds = '';
            if (fileList && fileList.length) {
                this._getAli([], function (ossClient) {
                    fileList.forEach(function (file) {
                        if (file && file['fileId'] && !file['name']) {
                            fileIds += file['fileId'] + ',';
                        }
                    });
                    if (fileIds.length) {
                        _this2.setState({
                            loading: true
                        }, function () {
                            _this2.getFileByIds(fileIds, function (data) {
                                var _fileList = [];
                                if (data && data.length) {
                                    fileList.forEach(function (file) {
                                        var ossFile = void 0;
                                        if (file && file['fileId'] && !file['name']) {
                                            data.forEach(function (_file) {
                                                if (file['fileId'] === _file['fileId']) {
                                                    ossFile = ossFileUtils.getOssFile(_file.fileId, _file.fileOriginalName, _file.fileMimeType, _file.fileSize, _file.fileUri);
                                                    ossFile['uid'] = new Date().getTime();
                                                }
                                            });
                                        } else {
                                            ossFile = _extends({}, file);
                                        }
                                        _fileList.push(ossFile);
                                    });
                                }
                                _this2.setState({
                                    loading: false,
                                    fileList: _fileList
                                });
                            });
                        });
                    }
                });
            }
        }

        /**
         * 根据fileId获取文件内容
         */

    }, {
        key: 'getFileByIds',
        value: function getFileByIds(fileIds, callback) {
            this.doAction({
                path: 'upload/getFileInfo',
                payload: {
                    params: { fileIds: fileIds },
                    success: function success(e) {
                        callback && callback(e);
                    }
                }
            });
        }

        /**
         * 网络监控，重连发起断点续传
         * upload自带了这个功能，暂时没用上
         */


        /**
         * 获取上传凭证
         */


        /**
         * 文件上传前在后台创建file实体
         */


        /**
         * 文件上传成功后改变后台的file状态
         */


        /**
         * 上传文件结果回调
         */

    }, {
        key: '_value',
        value: function _value(nextProps, nextState) {
            var protect = this.props.protect;

            if (protect && nextProps['value'].length < this.state.fileList.length && Object.keys(this.progress).length) {
                Wizmessage.error('文件正在上传中, 请等上传完成后进行操作');
                return false;
            } else {
                nextState['fileList'] = nextProps['value'];
                return true;
            }
        }
    }, {
        key: '_uploadingFile',
        value: function _uploadingFile(nextProps, nextState) {
            var uploadingFile = nextState['uploadingFile'];
            var fileList = nextState['fileList'];
            var fs = [].concat(_toConsumableArray(fileList));
            if (uploadingFile && uploadingFile.length) {
                uploadingFile.forEach(function (uf) {
                    var flag = false;
                    fileList.forEach(function (f) {
                        if (uf['uid'] === f['uid']) {
                            flag = true;
                        }
                    });
                    if (!flag) {
                        uf['status'] = 'uploading';
                        fs.push(uf);
                    }
                });
            }
            nextState['fileList'] = fs;
            return true;
        }

        /**
         * 上传文件时，文件状态的改变
         */


        /**
         * 文件上传前的回调
         */


        /**
         * 文件状态变化
         */


        /**
         * 移除文件
         */


        /**
         * 文件出错的状态
         */


        /**
         * 文件上传（支持多文件、分片上传）
         */


        /**
         * 检查文件是否需要分片上传
         */


        /**
         * 获取Blob对象
         * @param {*} fileSource 
         * @param {*} callback 
         */


        /**
         * S3普通文件上传
         */


        /**
         * S3分片上传（超过5兆）
         */


        /**
         * S3分片上传成功回调
         */


        /**
         * 普通文件上传
         */


        /**
         * 分片上传（超过1兆）
         */


        /**
         * 断点续传
         */


        /**
         * 分片/断点 进度回调
         */


        /**
         * 检查ali凭证时效
         */


        /**
         * 分片/断点 上传成功回调
         */


        /**
         * 分片/断点 上传失败回调
         */

    }, {
        key: '_render',
        value: function _render() {
            if (isIE()) return null;
            var _state = this.state,
                fileList = _state.fileList,
                loading = _state.loading;

            if (loading) {
                return React.createElement(WizSpin, { spinning: loading, tip: '\u6570\u636E\u52A0\u8F7D\u4E2D' });
            } else {
                var children = this.props.children;

                var upload = _extends({}, this.props, {
                    beforeUpload: this.beforeUpload,
                    fileList: fileList,
                    onChange: this._onChange,
                    onRemove: this._onRemove
                });
                var selectView = children !== undefined ? children : React.createElement(
                    WizButton,
                    null,
                    '\u9009\u62E9\u6587\u4EF6'
                );
                return React.createElement(
                    Upload,
                    upload,
                    selectView
                );
            }
        }
    }]);

    return WizOssUpload;
}(WizContainer);

WizOssUpload.defaultProps = {
    /**
     * 向服务端归档的类型，决定储存空间：
     * courseWare 课件， ⭐️课件类型需要额外传 课件编号：courseNumber  版本：version 课件类型：courseType
     * system 系统文件， 
     * temp 临时文件  
     * homework 作业文件
     */
    uploadType: 'system',
    /**
     * 文件的监听，实时返回文件状态
     */
    onChange: function onChange() {},
    /**
     * 上传中文件的保护，默认true。当值为true时，正在上传中的文件不允许被删除
     */
    protect: true
};


var mapStateToProps = function mapStateToProps(state, ownProps) {
    return {};
};

var options = { withRef: true };

export default connect(mapStateToProps, null, null, options)(WizOssUpload);