@bigfishtv/cockpit/es/api/tankUpload.js

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; };

/**
 * Tank Upload API
 * @module API/tankUpload
 */

import plupload from '../../lib/plupload';
import { post, get } from 'axios';
import { update } from '@bigfishtv/react-forms';

import pluploadSettings from '../config/pluploadSettings';

import { notifyFailure } from '../actions/notifications';
import { updateMaximumUploadSize } from '../actions/maximumUploadSize';

// eslint-disable-next-line no-unused-vars
var QUEUED = plupload.QUEUED,
    UPLOADING = plupload.UPLOADING,
    FAILED = plupload.FAILED,
    DONE = plupload.DONE;


var uploader = null;
var store = null;
var oldState = {};

var tempIdFolders = [];
var tempIds = [];

var uploaderSettings = _extends({}, pluploadSettings, {
	browse_button: document.createElement('div'),
	multi_selection: true,
	init: {
		PostInit: PostInit,
		FilesAdded: FilesAdded,
		BeforeUpload: BeforeUpload,
		UploadProgress: UploadProgress,
		FileUploaded: FileUploaded,
		Error: Error
	}

	/**
  * Gets real asset id from tempIds array
  * @param  {String} tempId
  * @return {String}
  */
});export function getIdFromTemp(tempId) {
	return tempIds[tempId] || false;
}

/**
 * Returns plupload instance
 * @return {Plupload}
 */
export function getUploader() {
	if (!uploader) return;
	return uploader;
}

/**
 * Makes reference to redux store and inits plupload instance
 * @param  {Object} _store
 * @param  {Object} settings
 * @param  {String} settings.max_file_size 		- default '10mb'
 * @param  {String} settings.runtimes 			- default 'html5,flash,html4'
 * @param  {String} settings.url  				- default '/tank/assets/upload/'
 * @param  {String} settings.flash_swf_url 		- default '/tank/lib/plupload/Moxie.swf'
 * @param  {Boolean} settings.urlstream_upload 	- default true
 * @param  {Boolean} settings.multi_selection 	- default true
 * @param  {DOM} settings.browse_button
 * @param  {Object} settings.init
 * @return {Plupload}
 */
export function init(_store) {
	var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : uploaderSettings;

	if (uploader !== null) {
		return;
	}

	store = _store;

	settings = update(settings, ['headers', 'X-CSRF-Token'], store.getState().csrfToken);

	uploader = new plupload.Uploader(settings);
	uploader.init();

	oldState = store.getState();
	store.subscribe(function () {
		var newState = store.getState();

		if (oldState.maximumUploadSize !== newState.maximumUploadSize) {
			uploader.setOption('max_file_size', newState.maximumUploadSize / 1024 / 1024 + 'mb');
		}

		oldState = newState;
	});

	get('/tank/assets/maximumUploadSize').then(function (response) {
		if (typeof response.data == 'number') store.dispatch(updateMaximumUploadSize(response.data));
	});

	return uploader;
}

/**
 * Add native file to plupload instance and start uploading
 * @param {Object} file - native file
 * @param {Number} [folder_id=null]
 * @return {String} - returns temporary asset id
 */
export function addFile(file) {
	var folder_id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

	uploader.addFile(file);
	var lastFile = uploader.files[uploader.files.length - 1];
	tempIdFolders[lastFile.id] = folder_id;
	uploader.start();

	return lastFile.id;
}

function PostInit() {}

function FilesAdded(uploader, files) {}

/**
 * Before upload begins we request a file id from tank and then begin upload upon asset request approval
 * @param {Plupload} uploader
 * @param {Object} file
 */
function BeforeUpload(uploader, file) {
	var folder_id = tempIdFolders[file.id];
	post('/tank/assets/create', { filename: file.name, tempId: file.id, folder_id: folder_id }).then(function (response) {
		tempIds[file.id] = response.data.id;
		file.asset = response.data;
		uploader.settings.multipart_params.asset = response.data;
		file.status = plupload.UPLOADING;
		uploader.trigger('UploadFile', file);
	}, function (error) {
		uploader.removeFile(file);
		store.dispatch(notifyFailure('Uploader error requesting asset admittance (' + error.status + ') - ' + error.statusText));
	});
	return false;
}

function UploadProgress(uploader, file) {}

function FileUploaded(uploader, file, response) {
	var allDone = true;
	for (var _iterator = uploader.files, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;

		if (_isArray) {
			if (_i >= _iterator.length) break;
			_ref = _iterator[_i++];
		} else {
			_i = _iterator.next();
			if (_i.done) break;
			_ref = _i.value;
		}

		var _file = _ref;

		if (_file.status !== DONE) allDone = false;
	}
	if (allDone) uploader.splice();
}

function Error(uploader, error) {
	store.dispatch(notifyFailure('Uploader error (' + error.status + ') - ' + error.message));
	var badFile = error.file;
	if (badFile) {
		uploader.removeFile(badFile);
		if (badFile.asset) {
			post('/tank/assets/delete.json', [badFile.asset.id]);
		}
	}
}