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

/**
 * 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
const { QUEUED, UPLOADING, FAILED, DONE } = plupload

let uploader = null
let store = null
let oldState = {}

const tempIdFolders = []
const tempIds = []

const uploaderSettings = {
	...pluploadSettings,
	browse_button: document.createElement('div'),
	multi_selection: true,
	init: {
		PostInit,
		FilesAdded,
		BeforeUpload,
		UploadProgress,
		FileUploaded,
		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, settings = 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(() => {
		const 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(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, folder_id = null) {
	uploader.addFile(file)
	const 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) {
	const folder_id = tempIdFolders[file.id]
	post('/tank/assets/create', { filename: file.name, tempId: file.id, folder_id }).then(
		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)
		},
		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) {
	let allDone = true
	for (let file of uploader.files) {
		if (file.status !== DONE) allDone = false
	}
	if (allDone) uploader.splice()
}

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