complete

.meteor/packages

 
 npm-container
 momentjs:moment
+iron:router
+udondan:jszip

.meteor/versions

 htmljs@1.0.11
 http@1.2.11
 id-map@1.0.9
+iron:controller@1.0.12
+iron:core@1.0.11
+iron:dynamic-template@1.0.12
+iron:layout@1.0.12
+iron:location@1.0.11
+iron:middleware-stack@1.1.0
+iron:router@1.1.2
+iron:url@1.1.0
 jquery@1.11.10
 launch-screen@1.1.1
 less@2.7.9
 templating-tools@1.1.0
 tmeasday:check-npm-versions@0.2.0
 tracker@1.1.2
+udondan:jszip@2.4.0_1
 ui@1.0.12
 underscore@1.0.10
 url@1.1.0

client/main.js

 import React from 'react';
 import { Meteor } from 'meteor/meteor';
 import { render } from 'react-dom';
-import '../imports/startup/accounts-config.js';
 import App from '../imports/ui/App.jsx';
+import '../imports/startup/routes';
  
 Meteor.startup(() => {
-  render(<App />, document.getElementById('main'));
+	render(<App />, document.getElementById('main'));
 });

imports/api/links.js

 			if (err) {
 				console.log(url);
 				console.error(err);
-				Converted.update({ _id: id }, { $set: { error: 'Video is unreachable' } });
+				Converted.update({ _id: id }, { $set: {
+					error_video: 'Video is unreachable',
+					error_audio: 'Video is unreachable',
+				} });
 			} else {
 				const totalSeconds = info ? info.length_seconds : 0;
 				const dl = ytdl(url);
 				ffmpeg(dl)
 					.noVideo()
 					.on('end', Meteor.bindEnvironment(() => {
-						Converted.update({ _id: id }, { $set: { audio: audioPath, audio_progress: 100 } });
+						Converted.update({ _id: id }, { $set: { audio: filename + '.mp3', audio_progress: 100 } });
 					}))
 					.on('progress', Meteor.bindEnvironment((params) => {
 						const time = moment(new Date(...[0, 0, 0, ...params.timemark.split(':')]));
 						let percent = ((seconds / totalSeconds) * 100).toFixed(0);
 						Converted.update({ _id: id }, { $set: { audio_progress: percent } });
 					}))
-					.on('error', (err) => { console.error('MP3 encoding error: ' + err.message); })
+					.on('error', Meteor.bindEnvironment((err) => {
+						console.error('MP3 encoding error: ' + err.message);
+						Converted.update({ _id: id }, { $set: { error_audio: 'Audio cannot be extracted' } });
+					}))
 					.format('mp3')
 					.output(fs.createWriteStream(audioPath))
 					.run();
 						Converted.update({ _id: id }, { $set: { video_progress: (percent * 100).toFixed(0) } });
 					}));
 					res.on('end', Meteor.bindEnvironment(() => {
-						Converted.update({ _id: id }, { $set: { video: videoPath, video_progress: 100 } });
+						Converted.update({ _id: id }, { $set: { video: filename + '.mp4', video_progress: 100 } });
+					}));
+					res.on('error', Meteor.bindEnvironment((err) => {
+						console.error('Error: ' + err.message)
+						Converted.update({ _id: id }, { $set: { error_video: 'Video cannot be saved' } });
 					}));
-					res.on('error', (err) => { console.error('Error: ' + err.message) });
 				}));
 			}
 		}));
 	check(type, Match.Where(t => ['audio'].includes(t)));
 
  	let converted = Converted.findOne({
-		url: video.url
+		url: video.url,
+		error_audio: { $ne: null },
+		error_video: { $ne: null },
 	});
 
 	if (!converted) {
 		const filename = video.title.replace(/ /g, '_');
+		Converted.remove({url: video.url});
 		var inserted_id = Converted.insert({
 			id: video.id,
 			url: video.url,
 			title: video.title,
 			video: '',
 			video_progress: 0,
+			error_video: '',
 			audio: '',
 			audio_progress: 0,
+			error_audio: '',
 			createdAt: new Date()
 		});
 		convert(video.url, filename, inserted_id);

imports/startup/routes.js

+import { Converted } from '../api/links';
+
+const uploadedPath = '/home/kod3/projects/SoundWave/uploaded/';
+
+Router.route('/');
+
+Router.route("/:type/batch/:ids", function() {
+	const fs = Meteor.npmRequire('fs');
+	const path = Meteor.npmRequire('path');
+
+	let { type, ids } = this.params;
+	ids = ids.split(',');
+	let file = (type === 'mp3' ? 'audio' : 'video');
+	let videos = Converted.find({ id: { $in: ids } }).fetch();
+	if (!videos.length) {
+		this.response.writeHead(404);
+		this.response.end("Files not found");
+	} else {
+		let zip = new JSZip();
+		_.each(videos, video => zip.file(video[file], fs.readFileSync(path.resolve(uploadedPath, video[file]))));
+		this.response.setHeader("Content-Type", "application/octet-stream");
+		this.response.setHeader("Content-disposition", `attachment; filename=soundwave-${type}.zip`);
+		this.response.writeHead(200);
+		this.response.end(zip.generate({ type: "nodebuffer", compression: "DEFLATE" }));
+	}
+}, { where: 'server'});
+
+
+Router.route("/:type/:id", function() {
+	const fs = Meteor.npmRequire('fs');
+	const path = Meteor.npmRequire('path');
+
+	let { type, id } = this.params;
+	let file = (type === 'mp3' ? 'audio' : 'video');
+	let video = Converted.findOne({ id: id });
+
+	if (!video) {
+		this.response.writeHead(404);
+		this.response.end("File not found");
+	} else {
+		const filePath = path.resolve(uploadedPath, video[file]);
+		let stat = fs.statSync(filePath);
+		this.response.writeHead(200, {
+			'Content-Type': (type === 'mp3' ? 'audio/mpeg' : 'video/mp4'),
+			'Content-Length': stat.size
+		});
+		fs.createReadStream(filePath).pipe(this.response);
+	}
+}, { where: 'server'});

imports/ui/App.jsx

 import React, { Component, PropTypes } from 'react';
 import { Meteor } from 'meteor/meteor';
-import { Tracker } from 'meteor/tracker';
 import { createContainer } from 'meteor/react-meteor-data';
 import { Converted } from '../api/links';
 import Links from './Links';
 		super(props);
 		this.state = { result: [], links: [], value: '' };
 		this.options = [
-			{ type: 'MP3', handler: this.downloadAudio.bind(this) },
-			{ type: 'MP4', handler: this.downloadVideo.bind(this) },
+			{ type: 'MP3', handler: (video) => window.open('/mp3/'+ video.id) },
+			{ type: 'MP4', handler: (video) => window.open('/mp4/'+ video.id) },
 		];
 		this.optionsAll = [
-			{ type: 'MP3', handler: this.downloadAllAudio.bind(this) },
-			{ type: 'MP4', handler: this.downloadAllVideo.bind(this) },
+			{ type: 'MP3', handler: () => window.open(`/mp3/batch/${this.batchLinks()}`) },
+			{ type: 'MP4', handler: () => window.open(`/mp4/batch/${this.batchLinks()}`) },
 		];
 	}
 
 		);
 	}
 
-	downloadAudio(video) {
-		console.log('Requesting mp3 for ' + video.id);
-	}
-
-	downloadVideo(video) {
-		console.log('Requesting mp4 for ' + video.id);
-	}
-
-	downloadAllAudio() {
-		console.log('Requesting mp3 for all');
-	}
-
-	downloadAllVideo() {
-		console.log('Requesting mp4 for all');
+	batchLinks() {
+		return this.state.links.map(e => e.id).join(',');
 	}
 
 	inputChange(text) {

imports/ui/Options.jsx

 			!this.props.converted[type === 'MP3' ? 'audio' : 'video'];
 	}
 
-	getClasses() {
-		return classnames({
-			option: true,
-			unreachable: this.props.converted.error
-		});
+	getClasses(type) {
+		let option = true;
+		let unreachable = null;
+		if (this.props.converted)
+			unreachable = (type === 'MP3' ? this.props.converted.error_audio : this.props.converted.error_video);
+		return classnames({ option, unreachable });
 	}
 
-	getErrorMessage() {
-		return this.props.converted.error || null;
+	getErrorMessage(type) {
+		return (type === 'MP3' ? this.props.converted.error_audio : this.props.converted.error_video) || null;
 	}
 
 	render() {
 		return (
 			<div>
 				{ _.map(this.props.handlers, (h) => (
-					<button key={h.type} className={this.getClasses()}
+					<button key={h.type} className={this.getClasses(h.type)}
 							onClick={() => h.handler(this.props.video)}
-							disabled={this.isDisabled(h.type)} title={this.getErrorMessage()}>
+							disabled={this.isDisabled(h.type)} title={this.getErrorMessage(h.type)}>
 						<div className="option-progress" style={{width: this.getProgress(h.type) + '%'}}></div>
 						<i className="fa fa-download"/> {h.type}
 					</button>

imports/ui/Video.js

 	update(stats, duration) {
 		for (count in stats)
 			this.stats[count] = numeral(stats[count]).format('0.[00]a');
-		console.log(duration);
 		const time = moment.utc(moment.duration(duration).asMilliseconds())
 		this.duration = time.format(time.hours() ? 'k:mm:ss' : 'm:ss');
 	}

server/main.js

 import { Meteor } from 'meteor/meteor';
 import '../imports/api/links.js';
+import '../imports/startup/routes';
 
 Meteor.startup(() => {
   // code to run on server at startup
 });
+