drop.chapril.org-firefoxsend/app/controller.js

300 lines
7.7 KiB
JavaScript
Raw Normal View History

import FileSender from './fileSender';
import FileReceiver from './fileReceiver';
2018-07-31 20:09:18 +02:00
import { copyToClipboard, delay, openLinksInNewTab, percent } from './utils';
import * as metrics from './metrics';
2018-08-03 21:24:41 +02:00
import { bytes } from './utils';
2018-10-25 04:32:53 +02:00
import okDialog from './ui/okDialog';
2018-10-26 03:55:11 +02:00
import copyDialog from './ui/copyDialog';
import signupDialog from './ui/signupDialog';
export default function(state, emitter) {
let lastRender = 0;
2017-09-13 21:01:55 +02:00
let updateTitle = false;
function render() {
emitter.emit('render');
}
async function checkFiles() {
2018-08-08 00:40:17 +02:00
const changes = await state.user.syncFileList();
const rerender = changes.incoming || changes.downloadCount;
if (rerender) {
render();
}
}
2017-09-13 21:01:55 +02:00
function updateProgress() {
if (updateTitle) {
emitter.emit('DOMTitleChange', percent(state.transfer.progressRatio));
}
render();
}
emitter.on('DOMContentLoaded', () => {
document.addEventListener('blur', () => (updateTitle = true));
document.addEventListener('focus', () => {
updateTitle = false;
emitter.emit('DOMTitleChange', 'Firefox Send');
});
checkFiles();
});
emitter.on('render', () => {
lastRender = Date.now();
});
emitter.on('login', email => {
state.user.login(email);
2018-08-08 00:40:17 +02:00
});
emitter.on('logout', () => {
state.user.logout();
2019-02-12 20:50:06 +01:00
metrics.loggedOut({ trigger: 'button' });
2018-08-31 23:20:15 +02:00
emitter.emit('pushState', '/');
2018-08-08 00:40:17 +02:00
});
2018-10-25 04:07:10 +02:00
emitter.on('removeUpload', file => {
state.archive.remove(file);
if (state.archive.numFiles === 0) {
state.archive.clear();
}
2018-08-03 21:24:41 +02:00
render();
2018-07-31 20:09:18 +02:00
});
2019-02-12 20:50:06 +01:00
emitter.on('delete', async ownedFile => {
try {
metrics.deletedUpload({
2019-02-12 20:50:06 +01:00
size: ownedFile.size,
time: ownedFile.time,
speed: ownedFile.speed,
type: ownedFile.type,
ttl: ownedFile.expiresAt - Date.now(),
location
});
2019-02-12 20:50:06 +01:00
state.storage.remove(ownedFile.id);
await ownedFile.del();
} catch (e) {
state.raven.captureException(e);
}
2018-10-25 04:07:10 +02:00
render();
});
emitter.on('cancel', () => {
state.transfer.cancel();
});
2018-07-31 20:09:18 +02:00
emitter.on('addFiles', async ({ files }) => {
2018-11-19 19:48:52 +01:00
if (files.length < 1) {
return;
}
2018-08-08 00:40:17 +02:00
const maxSize = state.user.maxSize;
try {
state.archive.addFiles(
files,
maxSize,
state.LIMITS.MAX_FILES_PER_ARCHIVE
);
2018-08-08 00:40:17 +02:00
} catch (e) {
if (e.message === 'fileTooBig' && maxSize < state.LIMITS.MAX_FILE_SIZE) {
2019-02-12 20:50:06 +01:00
return emitter.emit('signup-cta', 'size');
}
2019-02-12 20:50:06 +01:00
state.modal = okDialog(
state.translate(e.message, {
size: bytes(maxSize),
count: state.LIMITS.MAX_FILES_PER_ARCHIVE
2019-02-12 20:50:06 +01:00
})
);
2018-07-31 20:09:18 +02:00
}
render();
});
2019-02-12 20:50:06 +01:00
emitter.on('signup-cta', source => {
2019-03-05 21:58:40 +01:00
const query = state.query;
state.user.startAuthFlow(source, {
campaign: query.utm_campaign,
content: query.utm_content,
medium: query.utm_medium,
source: query.utm_source,
term: query.utm_term
});
2019-02-12 20:50:06 +01:00
state.modal = signupDialog(source);
render();
});
emitter.on('authenticate', async (code, oauthState) => {
try {
await state.user.finishLogin(code, oauthState);
await state.user.syncFileList();
emitter.emit('replaceState', '/');
} catch (e) {
emitter.emit('replaceState', '/error');
setTimeout(render);
}
});
emitter.on('upload', async () => {
if (state.storage.files.length >= state.LIMITS.MAX_ARCHIVES_PER_USER) {
2018-09-07 19:53:40 +02:00
state.modal = okDialog(
2018-08-08 00:40:17 +02:00
state.translate('tooManyArchives', {
count: state.LIMITS.MAX_ARCHIVES_PER_USER
2018-08-08 00:40:17 +02:00
})
);
2018-09-07 19:53:40 +02:00
return render();
2018-08-08 00:40:17 +02:00
}
2019-02-12 20:50:06 +01:00
const archive = state.archive;
2018-08-31 23:20:15 +02:00
const sender = new FileSender();
2018-08-08 20:07:09 +02:00
2017-09-13 21:01:55 +02:00
sender.on('progress', updateProgress);
sender.on('encrypting', render);
2018-07-31 20:09:18 +02:00
sender.on('complete', render);
state.transfer = sender;
state.uploading = true;
render();
2018-01-24 19:23:13 +01:00
const links = openLinksInNewTab();
await delay(200);
2019-02-12 20:50:06 +01:00
const start = Date.now();
try {
2019-02-12 20:50:06 +01:00
const ownedFile = await sender.upload(archive, state.user.bearerToken);
2018-01-24 19:23:13 +01:00
state.storage.totalUploads += 1;
2019-02-12 20:50:06 +01:00
const duration = Date.now() - start;
metrics.completedUpload(archive, duration);
2018-01-24 19:23:13 +01:00
state.storage.addFile(ownedFile);
2018-08-31 23:20:15 +02:00
// TODO integrate password into /upload request
2019-02-12 20:50:06 +01:00
if (archive.password) {
emitter.emit('password', {
password: archive.password,
file: ownedFile
});
2018-07-31 20:09:18 +02:00
}
2018-10-29 17:52:24 +01:00
state.modal = copyDialog(ownedFile.name, ownedFile.url);
} catch (err) {
if (err.message === '0') {
//cancelled. do nothing
2019-02-12 20:50:06 +01:00
const duration = Date.now() - start;
metrics.cancelledUpload(archive, duration);
render();
} else {
// eslint-disable-next-line no-console
console.error(err);
state.raven.captureException(err);
2019-02-12 20:50:06 +01:00
metrics.stoppedUpload(archive);
emitter.emit('pushState', '/error');
}
} finally {
openLinksInNewTab(links, false);
2019-02-12 20:50:06 +01:00
archive.clear();
state.uploading = false;
state.transfer = null;
await state.user.syncFileList();
2018-10-25 04:07:10 +02:00
render();
}
});
2018-01-24 19:23:13 +01:00
emitter.on('password', async ({ password, file }) => {
try {
2018-02-16 21:56:53 +01:00
state.settingPassword = true;
render();
2018-01-24 19:23:13 +01:00
await file.setPassword(password);
state.storage.writeFile(file);
2018-02-16 21:56:53 +01:00
await delay(1000);
2018-01-24 19:23:13 +01:00
} catch (err) {
2018-03-02 06:36:45 +01:00
// eslint-disable-next-line no-console
2018-01-24 19:23:13 +01:00
console.error(err);
2018-02-21 21:35:52 +01:00
state.passwordSetError = err;
} finally {
state.settingPassword = false;
}
render();
});
2018-01-24 19:23:13 +01:00
emitter.on('getMetadata', async () => {
const file = state.fileInfo;
2018-07-07 00:49:50 +02:00
2018-01-24 19:23:13 +01:00
const receiver = new FileReceiver(file);
try {
2018-01-24 19:23:13 +01:00
await receiver.getMetadata();
state.transfer = receiver;
} catch (e) {
2018-08-08 00:40:17 +02:00
if (e.message === '401' || e.message === '404') {
file.password = null;
2018-01-24 19:23:13 +01:00
if (!file.requiresPassword) {
return emitter.emit('pushState', '/404');
}
}
}
2018-07-05 21:40:49 +02:00
render();
});
emitter.on('download', async file => {
state.transfer.on('progress', updateProgress);
state.transfer.on('decrypting', render);
2018-07-31 20:09:18 +02:00
state.transfer.on('complete', render);
const links = openLinksInNewTab();
const size = file.size;
2019-02-12 20:50:06 +01:00
const start = Date.now();
try {
2018-07-31 20:29:26 +02:00
const dl = state.transfer.download({
stream: state.capabilities.streamDownload
});
render();
await dl;
state.storage.totalDownloads += 1;
2019-02-12 20:50:06 +01:00
const duration = Date.now() - start;
metrics.completedDownload({
size,
duration,
password_protected: file.requiresPassword
});
} catch (err) {
2018-01-24 19:23:13 +01:00
if (err.message === '0') {
// download cancelled
state.transfer.reset();
render();
} else {
// eslint-disable-next-line no-console
state.transfer = null;
const location = err.message === '404' ? '/404' : '/error';
if (location === '/error') {
state.raven.captureException(err);
2019-02-12 20:50:06 +01:00
const duration = Date.now() - start;
metrics.stoppedDownload({
size,
duration,
password_protected: file.requiresPassword
});
}
emitter.emit('pushState', location);
}
} finally {
openLinksInNewTab(links, false);
}
});
2019-02-12 20:50:06 +01:00
emitter.on('copy', ({ url }) => {
copyToClipboard(url);
2019-02-12 20:50:06 +01:00
// metrics.copiedLink({ location });
});
2018-01-24 19:23:13 +01:00
setInterval(() => {
// poll for updates of the upload list
2019-03-01 23:12:23 +01:00
if (!state.modal && state.route === '/') {
2018-01-24 19:23:13 +01:00
checkFiles();
}
}, 2 * 60 * 1000);
setInterval(() => {
// poll for rerendering the file list countdown timers
if (
2019-03-01 23:12:23 +01:00
!state.modal &&
state.route === '/' &&
state.storage.files.length > 0 &&
Date.now() - lastRender > 30000
) {
render();
}
}, 60000);
}