@pixwel/pixwel-sdk 1.1.0

package/src/Filename.js

@@ -0,0 +1,260 @@
+import _ from "lodash";
+
+/**
+ * The Filename class parses a filename into tokens, and can also take a set of
+ * tokens and create a valid Pixwel filename.
+ * @type class
+ */
+export default class Filename {
+	/**
+	 * Renders a valid filename given all tags, all types, an asset, and metadata
+	 * options likely parsed from the file itself.
+	 * @param  {Array}  [allTags=[]]  Collection of all known tags
+	 * @param  {Array}  [allTypes=[]] Collection of all known types
+	 * @param  {Object} [asset={}]    A Platform Asset
+	 * @param  {Object} [options={}] options containing metadata about file
+	 * @param  {String} [mediaType=''] Indicates video, audio, image and allows for stricter required fields
+	 * @return {String}               A valid filename
+	 */
+	static render(
+		allTags = [],
+		allTypes = [],
+		asset = {},
+		options = {},
+		mediaType = ""
+	) {
+		if (!asset.project) {
+			throw "missing asset.project";
+		}
+
+		if (asset.project && !asset.project.filePrefix) {
+			throw "missing asset.project.filePrefix";
+		}
+
+		if (!asset.name) {
+			throw "missing asset.name";
+		}
+
+		if (!asset.type) {
+			throw "missing asset.type";
+		}
+
+		if (asset.type.match(/^film-clip|^featurette/) && !asset.length) {
+			throw "missing asset.length";
+		}
+
+		let defaults = {
+			language: null,
+			country: null,
+			version: null,
+			tags: {
+				Usage: null,
+				Aspect: null,
+				SubDub: {
+					sub: null,
+					dub: null
+				},
+				Resolution: null,
+				"Frame Mode": null,
+				Framerate: null,
+				Text: null,
+				Codec: null,
+				Extra: []
+			}
+		};
+		options = _.merge(defaults, options);
+
+		if (!options.language) {
+			throw "missing options.language";
+		}
+
+		if (
+			!options.tags.SubDub.sub &&
+			!options.tags.SubDub.dub &&
+			!options.tags.Text
+		) {
+			throw "missing options.tags.Text or options.tags.SubDub";
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Codec) {
+			throw "missing options.tags.Codec";
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Resolution) {
+			throw "missing options.tags.Resolution";
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Framerate) {
+			throw "missing options.tags.Framerate";
+		}
+
+		if (mediaType == "video" && !options.tags["Frame Mode"]) {
+			throw "missing options.tags[Frame Mode]";
+		}
+
+		// currently, slurpee's filename.ts will render this, but we can add this back in later when
+		// filename.ts starts to rely on Filename.render
+		// if ((options.tags.SubDub.dub || options.tags.SubDub.sub) && options.tags.Text) {
+		//     throw 'conflicting options supplied: SubDub and Text';
+		// }
+
+		function assetType(asset, types) {
+			if (/trailer/.test(asset.type)) {
+				return false;
+			}
+
+			let matchingType = _.find(types, { name: asset.type });
+			if (!matchingType) {
+				throw `Asset type "${asset.type}" could not be found`;
+			}
+
+			return (
+				matchingType.file || matchingType.name.replace(".", "-").toUpperCase()
+			);
+		}
+
+		function assetTitle(asset) {
+			let prefix = "";
+			let name = asset.slug.toUpperCase().replace("INT-L", "INTL");
+			if (/trailer/.test(asset.type)) {
+				switch (asset.type) {
+					case "trailer.intl":
+						prefix = "ITR-";
+						name = name.replace(/INTL-TRAILER-/, "");
+						break;
+					case "trailer":
+						prefix = "TR-";
+						name = name.replace(/TRAILER-/, "");
+						break;
+					case "trailer.us":
+						prefix = "DTR-";
+						name = name.replace(/DOMESTIC-TRAILER-/, "");
+						break;
+				}
+			}
+			return prefix + name;
+		}
+
+		function runningTime(asset) {
+			let matches = asset.type.match(/^film-clip|^featurette/);
+			if (!matches) {
+				return;
+			}
+
+			let minutes = Math.floor(asset.length / 60);
+			let seconds = asset.length % 60;
+
+			let result = "";
+
+			if (minutes > 0) {
+				result += minutes + "min";
+			}
+
+			if (seconds > 0) {
+				result += seconds + "sec";
+			}
+
+			return result;
+		}
+
+		function locale(country, language) {
+			return [language, country]
+				.filter(str => {
+					return !!str && str !== "WW";
+				})
+				.join("-");
+		}
+
+		function textType(subDub, text) {
+			if (!subDub || (!subDub.sub && !subDub.dub)) {
+				return text;
+			}
+
+			let result = [];
+			if (subDub.sub) {
+				result.push("sub");
+			}
+
+			if (subDub.dub) {
+				result.push("dub");
+			}
+
+			return result;
+		}
+
+		function matchSet(allTags, tags) {
+			let selectedTags = _(tags)
+				.values()
+				.flatten()
+				.value();
+
+			let setTag = _(allTags)
+				.filter("set")
+				.find(setTag => {
+					return _.difference(setTag.set, selectedTags).length === 0;
+				});
+
+			if (setTag) {
+				return setTag.name;
+			}
+		}
+
+		let tags = options.tags,
+			parts = [
+				asset.project.filePrefix,
+				assetType(asset, allTypes),
+				assetTitle(asset),
+				runningTime(asset),
+				locale(options.country, options.language),
+				textType(tags.SubDub, tags.Text),
+				tags.Extra.join("_"),
+				options.version,
+				tags.Codec
+			];
+
+		parts = _(parts)
+			.flatten()
+			.filter()
+			.map(part => part.toUpperCase());
+
+		let matchedSet = matchSet(allTags, options.tags);
+		let requiredInfo = tags.Resolution && tags["Frame Mode"] && tags.Framerate;
+
+		if (matchedSet) {
+			parts = parts.push(matchedSet);
+		} else if (mediaType == "video" && tags.Resolution && !requiredInfo) {
+			parts = parts.push(tags.Resolution.replace(/\d+x/, ""));
+		} else if (mediaType == "image" && tags.Resolution) {
+			parts = parts.push(tags.Resolution);
+		}
+
+		let name = parts.join("_");
+
+		let hasResInfo = name.match(/\d+(i|p)/i);
+		let hasAllInfo = name.match(/\d+(i|p)\d+/i);
+
+		if (requiredInfo && !hasResInfo && !hasAllInfo) {
+			let res = tags.Resolution;
+			let encodeTag = [
+				hasResInfo ? "" : res.indexOf("x") ? res.replace(/\d+x/, "") : res,
+				res.match(/i|p/i) && !hasResInfo
+					? ""
+					: tags["Frame Mode"].toLowerCase().slice(0, 1),
+				tags.Framerate.replace(".", "").toUpperCase()
+			]
+				.filter(val => {
+					return val;
+				})
+				.join("");
+
+			let match = new RegExp(encodeTag, "i");
+			name = name.match(match)
+				? name.replace(match, encodeTag)
+				: name + "_" + encodeTag;
+		} else if (hasResInfo && !hasAllInfo && tags.Framerate) {
+			name += tags.Framerate.replace(".", "").toUpperCase();
+		}
+
+		return name;
+	}
+}

package/src/Ingest.js

@@ -0,0 +1,175 @@
+import _ from "lodash";
+
+/**
+ * [media description]
+ * @type {[type]}
+ */
+export default class Ingest {
+	/**
+	 * [mapMetaToTags description]
+	 * @param  {[type]} info [description]
+	 * @return {[type]}      [description]
+	 */
+	static mapMetaToTags(info, mediaType) {
+
+		let tags = {
+			Aspect: "",
+			Standard: "",
+			Resolution: "",
+			Codec: "",
+			"Frame Mode": "",
+			Text: "",
+			Usage: "",
+			Extra: [],
+			Framerate: "",
+			Duration: ""
+		};
+
+		switch (mediaType) {
+			case 'video':
+				mediaType = 'Video';
+				break;
+			case 'image':
+				mediaType = 'Image';
+				break;
+			default:
+				return tags;
+		}
+
+		if (!info.File) {
+			throw "missing info.File";
+		}
+
+		if (!info.File.track) {
+			throw "missing info.File.track";
+		}
+
+		let mediainfoDefaults = {
+			Display_aspect_ratio: "",
+			Format: "",
+			Standard: "",
+			Height: "",
+			Width: "",
+			Frame_rate: "",
+			Scan_type: ""
+		};
+
+		let media = _.find(info["File"]["track"], {
+			_type: mediaType
+		});
+		media = _.merge({}, mediainfoDefaults, media);
+
+		let width = parseInt(media["Width"].replace(" ", "").match(/[0-9 ]+/));
+		let height = parseInt(media["Height"].replace(" ", "").match(/[0-9 ]+/));
+		tags.Resolution = width && height ? `${width}x${height}` : "";
+
+		tags.Standard = media["Standard"] ? media["Standard"].toLowerCase() : "";
+
+		let scan = /Progressive/.test(media["Scan_type"]) ? "p" : "i";
+		let dimension = /3D/.test(name) ? "3D" : "2D";
+
+		let framerate = media["Frame_rate"].split(" ");
+		if (framerate.length) {
+			let f = framerate[0];
+			if (f == "23.976") {
+				f = "23.98";
+			}
+			f = parseFloat(f).toString();
+			tags.Framerate = f != "NaN" ? f : "";
+		}
+
+		if (!tags.Standard) {
+			switch (tags.Framerate) {
+				case "24":
+				case "23.98":
+				case "29.97":
+				case "59.94":
+					tags.Standard = "ntsc";
+					break;
+				case "25":
+				case "50":
+					tags.Standard = "pal";
+					break;
+			}
+		}
+
+		tags.Codec = (function(codec) {
+			switch (codec) {
+				case "AVC":
+					return "h264";
+				case "ProRes":
+					return "prores";
+				default:
+					return "";
+			}
+		})(media["Format"]);
+
+		if (tags.Codec == "h264") {
+			tags.Usage = "online";
+		}
+
+		if (tags.Codec == "prores") {
+			tags.Usage = "broadcast";
+		}
+
+		tags.Aspect = media["Display_aspect_ratio"] || "";
+		tags["Frame Mode"] = media["Scan_type"].toLowerCase();
+
+		return tags;
+	}
+	static mapFromKnownData(context, order, tags, watermarks = []) {
+
+		if (order.asset) {
+			context = {
+				asset: order.asset._id,
+				project: order.project._id,
+				assetType: order.assetType,
+				purpose: "download"
+			};
+		}
+
+		let previewType = (function() {
+			if (order.isSub() && order.isDub()) return "both";
+			if (order.isDub()) return "dub";
+			if (order.isSub()) return "sub";
+		})();
+
+		let isPreviewEnabled =
+			tags.Codec == "prores" &&
+			tags.Resolution.split("x")[1] == "1080" &&
+			(tags.Framerate == "23.98" || tags.Framerate == "25") &&
+			watermarks.length;
+
+		let watermark = watermarks[0] ? watermarks[0]._id : "";
+
+		return {
+			workRequest: order._id,
+			selected: {
+				download: {
+					enabled: true,
+					country: order.country,
+					language: order.language,
+					tags: tags,
+					embargo: {
+						enabled: false
+					}
+				},
+				preview: {
+					enabled: isPreviewEnabled,
+					language: order.language,
+					revision: "Final",
+					type: previewType,
+					watermark: watermark,
+					embargo: {
+						enabled: false
+					}
+				},
+				thumbnail: {
+					enabled: false
+				}
+			},
+			context: context
+		};
+	}
+}
+ 

package/src/IngestFile.js

@@ -0,0 +1,6 @@
+export default class IngestFile {
+	constructor(file, order) {
+		this.file = file;
+	}
+	// renderedName, ingest, options
+}

package/src/IngestFileDrop.js

@@ -0,0 +1,157 @@
+import { Asset, Filename, Order, Ingest, IngestFile } from "@pixwel/pixwel-sdk";
+
+/**
+ * Collects file handles from HTML5, full paths from Aspera, inspects
+ * the dropped file using mediainfo, then renames the file according to
+ * the data from Mediainfo and the Order and submits it for upload.
+ * @type {Object}
+ */
+export default class IngestFileDrop {
+	/**
+	 * Map that contains data from HTML5 file drop and Aspera file drop
+	 * @type {Object}
+	 */
+	constructor(scope, Mediainfo, IngestUpload) {
+		this.map = {};
+		this.scope = scope;
+		this.IngestUpload = IngestUpload;
+		this.Mediainfo = Mediainfo;
+		this.asperaDropHandler = this.asperaDropHandler.bind(this);
+		this.htmlDropHandler = this.htmlDropHandler.bind(this);
+	}
+	/**
+	 * HTML file drop handler
+	 * @param  {[type]} e [description]
+	 * @return {[type]}   [description]
+	 */
+	htmlDropHandler(e) {
+		let files = e.dataTransfer.files;
+		for (var i = 0; i < files.length; i++) {
+			this.registerHtmlFile(files[i]);
+		}
+	}
+	/**
+	 * Aspera drop handler
+	 * @param  {[type]} data [description]
+	 * @return {[type]}      [description]
+	 */
+	asperaDropHandler(data) {
+		var that = this;
+		let files = data.files.dataTransfer.files;
+		if (!files.length) {
+			return;
+		}
+		for (var i = 0; i < files.length; i++) {
+			this.registerAsperaFile(files[i]);
+		}
+		return Promise.all(this.export()).then(renamed => {
+			that.IngestUpload.uploadFiles(renamed, {}).then(() => {
+				that.map = {};
+			});
+		});
+	}
+	/**
+	 * Registers and HTML file drop
+	 * @param  {[type]} file [description]
+	 * @return {[type]}      [description]
+	 */
+	registerHtmlFile(file) {
+		this.map[file.name] = file;
+	}
+	/**
+	 * Registers and Aspera file drop
+	 * @param  {[type]} file [description]
+	 * @return {[type]}      [description]
+	 */
+	registerAsperaFile(file) {
+		let basename = this.getBasename(file);
+		this.map[basename]["path"] = file.name;
+	}
+	/**
+	 * Gets correct basename for MacOS and Windows
+	 * @param  {[type]} file [description]
+	 * @return {[type]}      [description]
+	 */
+	getBasename(file) {
+		return file.name[0] === "/"
+			? file.name.split("/").pop()
+			: file.name.split("\\").pop();
+	}
+	/**
+	 * Renames and generates ingest record for internal filemap
+	 * @return {[type]} [description]
+	 */
+	export() {
+		var that = this;
+		return Object.values(this.map).map(file => {
+			return that.rename(file);
+		});
+	}
+	/**
+	 * Renames the file and decorates it with ingest data using data from
+	 * mediainfo and the Order
+	 * @param  {[type]} file [description]
+	 * @return {[type]}      [description]
+	 */
+	rename(file) {
+		var that = this;
+		return this.Mediainfo.inform(file).then(meta => {
+			let order;
+			let asset;
+			let mediaType = file.type.split("/")[0];
+
+			let tags = Ingest.mapMetaToTags(meta, mediaType);
+
+			if (!that.scope.workRequest) {
+				order = new Order();
+				asset = new Asset();
+				tags.Text = "txtd";
+				file.ingest = Ingest.mapFromKnownData(
+					that.scope.context,
+					order,
+					tags,
+					that.scope.watermarks
+				);
+				return file;
+			}
+
+			order = new Order(that.scope.workRequest);
+			asset = Asset.mapFromOrder(order);
+
+			let options = {
+				tags: tags,
+				country: order.country,
+				language: order.language
+			};
+
+			if (that.scope.request && that.scope.request.tag) {
+				options.tags.Extra = [that.scope.request.tag.replace(" ", "-")];
+			}
+
+			options.tags.SubDub = {
+				sub: order.isSub(),
+				dub: order.isDub()
+			};
+			if (!order.isSub() && !order.isDub()) {
+				options.tags.Text = "txtd";
+			}
+
+			let basename = Filename.render(
+				that.scope.tags,
+				that.scope.assetTypes,
+				asset,
+				options,
+				mediaType
+			);
+			let extension = file.name.split(".").pop();
+			file.renderedName = `${basename}.${extension}`;
+			file.ingest = Ingest.mapFromKnownData(
+				that.scope.context,
+				order,
+				tags,
+				that.scope.watermarks
+			);
+			return file;
+		});
+	}
+}

package/src/Order.js

@@ -0,0 +1,31 @@
+import _ from "lodash";
+import Filename from "./Filename.js";
+
+export default class Order {
+	constructor(data) {
+		let schema = {
+			_id: null,
+			asset: null,
+			project: null,
+			assetType: null,
+			country: null,
+			language: null,
+			dng: null
+		};
+		Object.assign(this, schema, data);
+	}
+	isDub() {
+		if (!this.dng) {
+			return null;
+		}
+		return _
+			.flattenDeep(Object.entries(this.dng))
+			.includes("Dedicated / Localized");
+	}
+	isSub() {
+		if (!this.dng) {
+			return null;
+		}
+		return _.flattenDeep(Object.entries(this.dng)).includes("Subtitled");
+	}
+}

package/src/Srt.js

@@ -0,0 +1,89 @@
+import _ from 'lodash';
+import TimeFormat from './TimeFormat';
+
+function stripTags(input, allowed) {
+    allowed = (((allowed || '') + '').toLowerCase().match(/<[a-z][a-z0-9]*>/g) || []).join('')
+    var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>/gi
+    var commentsAndPhpTags = /<!--[\s\S]*?-->|<\?(?:php)?[\s\S]*?\?>/gi
+    return input.replace(commentsAndPhpTags, '').replace(tags, function($0, $1) {
+        return allowed.indexOf('<' + $1.toLowerCase() + '>') > -1 ? $0 : ''
+    })
+}
+
+var SRT_STATE_SUBNUMBER = 0,
+    SRT_STATE_TIME = 1,
+    SRT_STATE_TEXT = 2,
+    SRT_STATE_BLANK = 3;
+
+export default {
+    parse: function(lines) {
+        var result = [],
+            state = SRT_STATE_SUBNUMBER,
+            subText = '',
+            subTime = '';
+
+        function time(subTime) {
+
+            var range = subTime.split(' --> ');
+            if (!TimeFormat.isValidTime(range[0]) || !TimeFormat.isValidTime(range[1])) {
+                throw new Error('Malformed SRT file');
+            }
+
+            return {
+                startTime: range[0],
+                stopTime: range[1]
+            };
+        }
+
+        lines.forEach(function(line) {
+            line = line.replace(/^\s+|\s+$/g, '');
+
+            switch (state) {
+                case SRT_STATE_SUBNUMBER:
+                    state = SRT_STATE_TIME;
+                    break;
+
+                case SRT_STATE_TIME:
+                    subTime = line;
+                    state = SRT_STATE_TEXT;
+                    break;
+
+                case SRT_STATE_TEXT:
+                    if (line !== '') {
+                        subText += (subText) ? "\n" + line : line;
+                        return;
+                    }
+                    result.push(Object.assign(time(subTime), {
+                        text: subText
+                    }));
+                    subText = '';
+                    state = SRT_STATE_SUBNUMBER;
+                    break;
+            }
+        });
+
+        return result;
+    },
+    export: function(lines) {
+        var result = '',
+            i = 1;
+
+        lines.forEach(function(line) {
+            if (line.text === undefined) {
+                return;
+            }
+
+            // Replace <br> tags with newlines. These tags may accidentally be stored in the translation
+            let text = _.unescape(line.text.replace(/<br>/g, '\n'));
+
+            // Remove any tags that may have made it into the translation (div tags seem to be the main problem).
+            // <b> <i> are the only two supported tags currently
+            text = stripTags(text, '<b><i>');
+
+            result += (i++) + "\n";
+            result += TimeFormat.startTime(line) + " --> " + TimeFormat.stopTime(line) + "\n";
+            result += text + "\n\n";
+        });
+        return result;
+    }
+};