@pixwel/pixwel-sdk 1.1.7 → 1.1.9

package/src/Filename.js

@@ -24,19 +24,19 @@ export default class Filename {
 		mediaType = ""
 	) {
 		if (!asset.project) {
-			throw "missing asset.project";
+			throw new Error("missing asset.project");
 		}
 
 		if (asset.project && !asset.project.filePrefix) {
-			throw "missing asset.project.filePrefix";
+			throw new Error("missing asset.project.filePrefix");
 		}
 
 		if (!asset.name) {
-			throw "missing asset.name";
+			throw new Error("missing asset.name");
 		}
 
 		if (!asset.type) {
-			throw "missing asset.type";
+			throw new Error("missing asset.type");
 		}
 
 		let defaults = {
@@ -61,39 +61,25 @@ export default class Filename {
 		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";
+			throw new Error("missing options.language");
 		}
 
 		if (mediaType && mediaType == "video" && !options.tags.Codec) {
-			throw "missing options.tags.Codec";
+			throw new Error("missing options.tags.Codec");
 		}
 
 		if (mediaType && mediaType == "video" && !options.tags.Resolution) {
-			throw "missing options.tags.Resolution";
+			throw new Error("missing options.tags.Resolution");
 		}
 
 		if (mediaType && mediaType == "video" && !options.tags.Framerate) {
-			throw "missing options.tags.Framerate";
+			throw new Error("missing options.tags.Framerate");
 		}
 
 		if (mediaType == "video" && !options.tags["Frame Mode"]) {
-			throw "missing options.tags[Frame Mode]";
+			throw new Error("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;
@@ -101,7 +87,7 @@ export default class Filename {
 
 			let matchingType = _.find(types, { name: asset.type });
 			if (!matchingType) {
-				throw `Asset type "${asset.type}" could not be found`;
+				throw new Error(`Asset type "${asset.type}" could not be found`);
 			}
 
 			return (
@@ -154,6 +140,9 @@ export default class Filename {
 		}
 
 		function locale(country, language) {
+			if (language.includes('-')) {
+				country = '';
+			}
 			return [language, country]
 				.filter(str => {
 					return !!str && str !== "WW";

package/src/Ingest.js

@@ -6,25 +6,26 @@ import _ from "lodash";
  */
 export default class Ingest {
 	/**
-	 * [mapMetaToTags description]
-	 * @param  {[type]} info [description]
-	 * @return {[type]}      [description]
+	 * Maps mediainfo metadata into ingest Tag format
+	 * @param {*} info
+	 * @param {*} mediaType
 	 */
-	static mapMetaToTags(info, mediaType) {
-
-		let tags = {
-			Aspect: "",
-			Standard: "",
-			Resolution: "",
-			Codec: "",
-			"Frame Mode": "",
-			Text: "",
-			Usage: "",
+	static mapFromMediainfo(info, mediaType) {
+		let schema = {
+			Aspect: null,
+			Standard: null,
+			Resolution: null,
+			Codec: null,
+			"Frame Mode": null,
+			Text: null,
+			Usage: null,
 			Extra: [],
-			Framerate: "",
-			Duration: ""
+			Framerate: null,
+			Duration: null
 		};
 
+		let tags = {};
+
 		if (!info.File) {
 			throw "missing info.File";
 		}
@@ -34,34 +35,34 @@ export default class Ingest {
 		}
 
 		let general;
-		if (!Array.isArray(info['File']['track'])) {
-			general = info['File']['track'];
+		if (!Array.isArray(info["File"]["track"])) {
+			general = info["File"]["track"];
 		} else {
-			general = _.find(info['File']['track'], { _type: 'General'});
+			general = _.find(info["File"]["track"], { _type: "General" });
 		}
-		
+
 		switch (mediaType) {
-			case 'video':
-				mediaType = 'Video';
+			case "video":
+				mediaType = "Video";
 				break;
-			case 'image':
-				mediaType = 'Image';
+			case "image":
+				mediaType = "Image";
 				break;
 			default:
-				if (general.Format && general.Format == 'MXF') {
-					tags.Usage = 'broadcast';
+				if (general.Format && general.Format == "MXF") {
+					tags.Usage = "broadcast";
 				}
 				return tags;
 		}
 
 		let mediainfoDefaults = {
-			Display_aspect_ratio: "",
+			DisplayAspectRatio: "",
 			Format: "",
 			Standard: "",
 			Height: "",
 			Width: "",
-			Frame_rate: "",
-			Scan_type: ""
+			FrameRate: "",
+			ScanType: ""
 		};
 
 		let media = _.find(info["File"]["track"], {
@@ -71,21 +72,41 @@ export default class Ingest {
 
 		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 Resolution = width && height ? `${width}x${height}` : null;
+		if (Resolution) {
+			tags.Resolution = Resolution;
+		}
 
-		let scan = /Progressive/.test(media["Scan_type"]) ? "p" : "i";
-		let dimension = /3D/.test(name) ? "3D" : "2D";
+		let Standard = media["Standard"] ? media["Standard"].toLowerCase() : null;
+		if (Standard) {
+			tags.Standard = Standard;
+		}
 
-		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 : "";
+		let framerate = media["FrameRate"];
+		switch (framerate) {
+			case "23.976":
+				framerate = "23.98";
+				break;
+			case "24.000":
+				framerate = "24";
+				break;
+			case "25.000":
+				framerate = "25";
+				break;
+			case "29.970":
+				framerate = "29.97";
+				break;
+			case "50.000":
+				framerate = "50";
+				break;
+			case "59.940":
+				framerate = "59.94";
+				break;
+		}
+		framerate = parseFloat(framerate).toString();
+		framerate = framerate != "NaN" ? framerate : null;
+		if (framerate) {
+			tags.Framerate = framerate;
 		}
 
 		if (!tags.Standard) {
@@ -103,16 +124,18 @@ export default class Ingest {
 			}
 		}
 
-		tags.Codec = (function(codec) {
-			switch (codec) {
-				case "AVC":
-					return "h264";
-				case "ProRes":
-					return "prores";
-				default:
-					return "";
-			}
-		})(media["Format"]);
+		let Codec;
+		switch (media["Format"]) {
+			case "AVC":
+				Codec = "h264";
+				break;
+			case "ProRes":
+				Codec = "prores";
+				break;
+		}
+		if (Codec) {
+			tags.Codec = Codec;
+		}
 
 		if (tags.Codec == "h264") {
 			tags.Usage = "online";
@@ -122,68 +145,195 @@ export default class Ingest {
 			tags.Usage = "broadcast";
 		}
 
-		if (general && general['Format'] == 'MXF') {
-			tags.Usage = 'broadcast';
+		if (general && general["Format"] == "MXF") {
+			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"
-			};
+		switch (media["DisplayAspectRatio"]) {
+			case "1.000":
+				tags.Aspect = "1:1";
+				break;
+			case "1.347":
+				tags.Aspect = "4:3";
+				break;
+			case "1.756":
+				tags.Aspect = "16:9";
+				break;
+			case "1.778":
+				tags.Aspect = "16:9";
+				break;
+			case "1.366":
+				tags.Aspect = "4:3";
+				break;
+			case "0.562":
+				tags.Aspect = "9:16";
+				break;
 		}
 
-		let previewType = (function() {
-			if (order.isSub() && order.isDub()) return "both";
-			if (order.isDub()) return "dub";
-			if (order.isSub()) return "sub";
-		})();
+		let ScanType = media["ScanType"].toLowerCase() || null;
+		if (ScanType) {
+			tags["Frame Mode"] = ScanType;
+		}
 
-		let isPreviewEnabled =
-			(tags.Codec == "prores" &&
-			tags.Resolution.split("x")[1] == "1080" &&
-			(tags.Framerate == "23.98" || tags.Framerate == "25") &&
-			watermarks.length) || null;
+		let ingest = {
+			selected: {
+				download: {
+					tags: tags
+				}
+			}
+		};
 
-		let watermark = watermarks[0] ? watermarks[0]._id : "";
+		return ingest;
+	}
+	/**
+	 * Maps parsed filename data to a partial ingest record for later merging
+	 * @param {*} filename
+	 * @param {*} allTags
+	 */
+	static mapFromFilename(filename, allTags) {
+		let tags = {
+			SubDub: {
+				sub: null,
+				dub: null
+			}
+		};
+		filename.file.tags.forEach(tag => {
+			let foundTag = _.find(allTags, { name: tag });
+			if (foundTag) {
+				if (foundTag.type == 'SubDub') {
+					if (foundTag.name == 'sub') {
+						tags.SubDub.sub = true;
+					}
+					if (foundTag.name == 'dub') {
+						tags.SubDub.dub = true;
+					}
+				} else {
+					tags[foundTag.type] = foundTag.name;
+				}
+			}
+		});
+		tags.Extra = filename.extra;
+		let ingest = {
+			selected: {
+				download: {
+					tags: tags
+				},
+				preview: {
+				}
+			}
+		};
+		if (filename.file.tags.includes('sub') && filename.file.tags.includes('dub')) {
+			ingest.selected.preview.type = 'both';
+		} else if (filename.file.tags.includes('sub')) {
+			ingest.selected.preview.type = 'sub';
+		} else if (filename.file.tags.includes('dub')) {
+			ingest.selected.preview.type = 'dub';
+		}
+		if (filename.file.language) {
+			ingest.selected.preview.language = filename.file.language;
+			ingest.selected.download.language = filename.file.language;
+		}
+		if (filename.file.country) {
+			ingest.selected.download.country = filename.file.country;
+		}
+		return ingest;
+	}
+	/**
+	 * Assembles Ingest based on weighted rules
+	 * @param {*} context
+	 * @param {*} filename
+	 * @param {*} mediainfo
+	 * @param {*} order
+	 */
+	static assemble(original, filename, mediainfo, order, watermarks = []) {
 
-		return {
+		let defaults = {
 			workRequest: order._id,
 			selected: {
 				download: {
 					enabled: true,
-					country: order.country,
-					language: order.language,
-					tags: tags,
+					tags: {
+						Extra: []
+					},
 					embargo: {
 						enabled: false
 					}
 				},
 				preview: {
-					enabled: isPreviewEnabled,
-					language: order.language,
-					revision: "Final",
-					type: previewType,
-					watermark: watermark,
+					enabled: false,
+					revision: 'Final',
+					type: 'none',
 					embargo: {
 						enabled: false
 					}
 				},
 				thumbnail: {
-					enabled: false
+					enabled: false,
+					position: 50
 				}
-			},
-			context: context
+			}
 		};
+
+		let ingest = _.merge(defaults, original, filename, mediainfo);
+
+		if (original.asset && original.asset.creative) {
+			ingest.selected.preview.revision = 'Unfinished';
+		}
+
+		if (!original.context.asset && filename.asset && filename.asset._id) {
+			ingest.selected.asset = filename.asset._id;
+		}
+
+		if (ingest.workRequest) {
+			ingest.selected.project = ingest.context.project;
+			ingest.selected.asset = ingest.context.asset;
+			ingest.selected.assetType = ingest.context.assetType;
+		}
+
+		if (ingest.workRequest) {
+			ingest.selected.download.tags.Extra = [];
+		}
+
+		if (original.context.tag) {
+			ingest.selected.download.tags.Extra = [original.context.tag];
+		}
+
+		if (order.territory) {
+			ingest.selected.download.country = order.territory;
+		}
+		if (order.language) {
+			ingest.selected.preview.language = order.language;
+			ingest.selected.download.language = order.language;
+		}
+		if (order._id) {
+			ingest.selected.download.tags.Text = 'txtd';
+		}
+		if (order.isSub() || order.isDub()) {
+			ingest.selected.download.tags.SubDub = {
+				sub: order.isSub(),
+				dub: order.isDub()
+			}
+		}
+		if (order.isSub()) {
+			ingest.selected.preview.type = "sub";
+		}
+		if (order.isDub()) {
+			ingest.selected.preview.type = "dub";
+		}
+		if (order.isSub() && order.isDub()) {
+			ingest.selected.preview.type = "both";
+		}
+
+		ingest.selected.preview.watermark = watermarks[0] ? watermarks[0]._id : "";
+
+		let tags = ingest.selected.download.tags;
+		ingest.selected.preview.enabled =
+			!!(tags.Codec == "prores" &&
+				tags.Resolution.split("x")[1] == "1080" &&
+				(tags.Framerate == "23.98" || tags.Framerate == "25") &&
+				watermarks.length) ||
+			false;
+
+		return ingest;
 	}
 }
- 

package/src/Order.js

@@ -14,18 +14,30 @@ export default class Order {
 		};
 		Object.assign(this, schema, data);
 	}
+	/**
+	 * Determines if an order should be classified as 'dubbed' based on its dng values
+	 */
 	isDub() {
 		if (!this.dng) {
 			return null;
 		}
+		if (this.dng.graphics && this.dng.graphics.includes('Dedicated / Localized')) {
+			return false;
+		}
 		return _
 			.flattenDeep(Object.entries(this.dng))
 			.includes("Dedicated / Localized");
 	}
+	/**
+	 * Determines in an order should be classified as 'subbed' based on its dng values
+	 */
 	isSub() {
 		if (!this.dng) {
 			return null;
 		}
-		return _.flattenDeep(Object.entries(this.dng)).includes("Subtitled");
+		if (this.dng === 'Graphics Only') return false;
+		return _
+			.flattenDeep(Object.entries(this.dng))
+			.includes("Subtitled");
 	}
 }