@pixwel/pixwel-sdk 2.0.0 → 2.1.0

package/src/Ingest.js

@@ -1,16 +1,285 @@
 import _ from "lodash";
+import File from "./File";
+import Model from "./Model";
+import { mediaType } from "./fileType";
+import { clone, keys, flatten, filter, values } from "ramda";
 
 /**
  * [media description]
  * @type {[type]}
  */
-export default class Ingest {
+export default class Ingest extends Model {
+	constructor(data) {
+		super(data);
+		this._resource = "ingests";
+	}
+	static get _resource() {
+		return 'ingests';
+	}
+	/**
+	 * Returns path given an ingest record
+	 *
+	 */
+	renderPath() {
+		let ingest = this.data();
+		if (!ingest.asset.project.studio.slug) {
+			throw new Error("missing studio slug");
+		}
+		if (!ingest.asset.project.slug) {
+			throw new Error("missing asset.project.slug");
+		}
+		if (!ingest.asset.project.slug) {
+			throw new Error("missing asset.project.slug");
+		}
+		return [
+			ingest.asset.project.studio.slug,
+			ingest.asset.project.slug,
+			ingest.asset.type
+		].join("/");
+	}
+	/**
+	 * Create a File from an Ingest object with path and filename
+	 *
+	 * @param {object} params
+	 */
+	renderFilename({ allTags, allTypes, order } = (params = {})) {
+		let asset = this.data().asset;
+		let options = this.data().selected.download;
+		let mediaType = this.data().asset.mediaType;
+
+		if (!asset.project) {
+			throw new Error("missing asset.project");
+		}
+
+		if (asset.project && !asset.project.filePrefix) {
+			throw new Error("missing asset.project.filePrefix");
+		}
+
+		if (!asset.name) {
+			throw new Error("missing asset.name");
+		}
+
+		if (!asset.type) {
+			throw new Error("missing asset.type");
+		}
+
+		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 new Error("missing options.language");
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Codec) {
+			throw new Error("missing options.tags.Codec");
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Resolution) {
+			throw new Error("missing options.tags.Resolution");
+		}
+
+		if (mediaType && mediaType == "video" && !options.tags.Framerate) {
+			throw new Error("missing options.tags.Framerate");
+		}
+
+		if (mediaType == "video" && !options.tags["Frame Mode"]) {
+			throw new Error("missing options.tags[Frame Mode]");
+		}
+
+		function assetType(asset, types) {
+			if (/trailer/.test(asset.type)) {
+				return false;
+			}
+
+			let matchingType = _.find(types, { name: asset.type });
+			if (!matchingType) {
+				throw new Error(`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) {
+			if (language.includes("-")) {
+				country = "";
+			}
+			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;
+	}
+	/**
+	 * Returns the mediaType of the ingest
+	 */
+	mediaType() {
+		return this.src.mediaType;
+	}
 	/**
 	 * Maps mediainfo metadata into ingest Tag format
-	 * @param {*} info
-	 * @param {*} mediaType
+	 *
 	 */
-	static mapFromMediainfo(info, mediaType) {
+	mapFromMediainfo() {
+		let info = this.mediainfo;
+		let mediaType = this.asset.mediaType;
+
 		let schema = {
 			Aspect: null,
 			Standard: null,
@@ -190,7 +459,9 @@ export default class Ingest {
 	 * @param {*} filename
 	 * @param {*} allTags
 	 */
-	static mapFromFilename(filename, allTags) {
+	mapFromFilename(params) {
+		let { allTags } = params;
+		let filename = this.filename;
 		let tags = {
 			SubDub: {
 				sub: null,
@@ -200,11 +471,11 @@ export default class Ingest {
 		filename.file.tags.forEach(tag => {
 			let foundTag = _.find(allTags, { name: tag });
 			if (foundTag) {
-				if (foundTag.type == 'SubDub') {
-					if (foundTag.name == 'sub') {
+				if (foundTag.type == "SubDub") {
+					if (foundTag.name == "sub") {
 						tags.SubDub.sub = true;
 					}
-					if (foundTag.name == 'dub') {
+					if (foundTag.name == "dub") {
 						tags.SubDub.dub = true;
 					}
 				} else {
@@ -218,16 +489,18 @@ export default class Ingest {
 				download: {
 					tags: tags
 				},
-				preview: {
-				}
+				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.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;
@@ -239,13 +512,45 @@ export default class Ingest {
 		return ingest;
 	}
 	/**
-	 * Assembles Ingest based on weighted rules
+	 * Create a File from an Ingest object
+	 *
+	 * @param {object} params 
+	 */
+	createFile(params) {
+		let { allTags, allTypes, order } = params;
+
+		this.filename = this.mapFromFilename({ allTags });
+		this.mediainfo = this.mapFromMediainfo();
+
+		let ingest = this.assemble({ order });
+
+		let file = new File({
+			name: this.renderFilename({ allTags, allTypes }),
+			path: this.renderPath(),
+			asset: ingest.asset._id,
+			generator: 'ingest',
+			contextTag: ingest.context.tag,
+			language: ingest.selected.download.language,
+			country: ingest.selected.download.country,
+			tags: flatValues(ingest.selected.download.tags),
+			ingest: ingest._id,
+			workRequest: ingest.workRequest,
+			verified: true
+		});
+
+		return file;
+	}
+	/**
+	 * Merges ingest metadata sources
 	 *
 	 * @param {object} params
 	 */
-	static assemble(params) {
+	assemble(params) {
+		let original = this.data();
+		let filename = this.data().filename;
+		let mediainfo = this.data().mediainfo;
 
-		let { original, filename, mediainfo, order, watermarks = [] } = params;
+		let { order, watermarks = [] } = params;
 
 		let defaults = {
 			workRequest: order._id,
@@ -261,8 +566,8 @@ export default class Ingest {
 				},
 				preview: {
 					enabled: false,
-					revision: 'Final',
-					type: 'none',
+					revision: "Final",
+					type: "none",
 					embargo: {
 						enabled: false
 					}
@@ -277,7 +582,7 @@ export default class Ingest {
 		let ingest = _.merge(defaults, filename, original, mediainfo);
 
 		if (original.asset && original.asset.creative) {
-			ingest.selected.preview.revision = 'Unfinished';
+			ingest.selected.preview.revision = "Unfinished";
 		}
 
 		if (!original.context.asset && filename.asset && filename.asset._id) {
@@ -306,13 +611,13 @@ export default class Ingest {
 			ingest.selected.download.language = order.language;
 		}
 		if (order._id) {
-			ingest.selected.download.tags.Text = 'txtd';
+			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";
@@ -328,12 +633,27 @@ export default class Ingest {
 
 		let tags = ingest.selected.download.tags;
 		ingest.selected.preview.enabled =
-			!!(tags.Codec == "prores" &&
+			!!(
+				tags.Codec == "prores" &&
 				tags.Resolution.split("x")[1] == "1080" &&
 				(tags.Framerate == "23.98" || tags.Framerate == "25") &&
-				watermarks.length) ||
-			false;
+				watermarks.length
+			) || false;
 
 		return ingest;
 	}
 }
+
+/**
+ * Flattens ingest.selected.download.tags into a simple array
+ *
+ * @param {object} data
+ */
+function flatValues(data) {
+	let copy = clone(data);
+	if (copy.SubDub) {
+		copy.SubDub = keys(filter(val => !!val, copy.SubDub));
+	}
+	return flatten(values(copy));
+}
+

package/src/Model.js

@@ -0,0 +1,252 @@
+import { Pixwel } from "../index";
+import axios from "axios";
+import { cloneDeep } from "lodash";
+import { diff } from "deep-object-diff";
+import validate from "validate.js";
+
+/**
+ * Model base class for reading and writing to an API
+ *
+ * - persistence
+ * - validation
+ * - schema / seal
+ * - API error response handling
+ * - API success response hanlding
+ * - throws Exceptions
+ *
+ */
+
+ var _bindings = {
+		find: [],
+		save: []
+ };
+
+ /**
+ * This exists outside the class, solely because I have not
+ * figured out how to reference a static class method from an instance
+ * and also from a static function.
+ */
+function connection() {
+	return axios.create({
+			baseURL: Pixwel.endpoint,
+			headers: {
+				Authorization: `Basic ${Pixwel.credentials.token}`,
+				Accept: "application/json",
+				"Content-Type": "application/json"
+			}
+		});
+}
+
+
+export default class Model {
+	constructor(data) {
+		Object.assign(this, data);
+		this._name = 'model';
+		this._endpoint = Pixwel.endpoint;
+		this._api = connection();
+		this._lastState = {};
+		this._validationErrors = [];
+		this._constraints = {};
+	}
+	/**
+	 * Adds a validation contraint
+	 *
+	 * @param {string} name 
+	 * @param {object} data 
+	 */
+	addConstraint(name, data) {
+		this._constraints[name] = data;
+	}
+	/**
+	 * Validates models data against its contraints
+	 */
+	validates() {
+		let res = validate(this.data(), this._constraints);
+		if (res == undefined) {
+			this._validationErrors = [];
+		} else {
+			this._validationErrors = res;
+		}
+		return (res == undefined) ? true : false;
+	}
+	errors() {
+		return this._validationErrors;
+	}
+	/**
+	 * Makes a request to the API
+	 *
+	 * @param {object} config
+	 */
+	async request(config) {
+		return this._api.request(config);
+	}
+	/**
+	 * Returns data
+	 */
+	data() {
+		let keys = Object.keys(this).filter(key => {
+			// using underscore convention to not include private data
+			return key[0] != '_';
+		});
+		// deliberately adding _id back in even though it's "private"
+		keys.push('_id');
+		let data = {};
+		keys.forEach(key => {
+			data[key] = this[key];
+		});
+		return data;
+	}
+	/**
+	 * Register a callback to a model method
+	 *
+	 * @param {string} method
+	 * @param {function} callback
+	 */
+	static registerCallback(method, callback) {
+		_bindings[method].push(callback);
+	}
+	/**
+	 * Creates or updates a resource depennding on the presence
+	 * of _id
+	 *
+	 * @param {object} data
+	 */
+	async save(data = {}) {
+		let input = data.length ? data : this.data();
+
+		if (input._id) {
+			let inputDiff = diff(this._lastState, input);
+			this._lastState = await this.update(input._id, inputDiff);
+		} else {
+			this._lastState = await this.create(input);
+		}
+
+		// fires events with the result
+		_bindings.save.forEach(callback => {
+			callback(this._lastState);
+		});
+
+		return this._lastState;
+	}
+	/**
+	 * Merges incoming data into the model data
+	 *
+	 * @param {object} data
+	 */
+	set(data) {
+		return Object.assign(this, data);
+	}
+	/**
+	 * Returns a deep clone of the current object
+	 */
+	clone() {
+		return cloneDeep(this);
+	}
+	/**
+	 * Fetches all objects in a collection given params
+	 *
+	 * @param {object} params
+	 */
+	static all(params = {})  {
+		return this.find(params);
+	}
+	/**
+	 * Finds an object or collection of objects
+	 *
+	 * @param {object} params
+	 */
+	static async find(params = {}) {
+		let api = connection();
+		let url;
+		if (typeof params === 'string') {
+			let id = params;
+			url = `${this._resource}/${id}`;
+			params = {};
+		} else {
+			url = this._resource;
+		}
+
+		try {
+			var res = await api.get(url, {params});
+		} catch (e) {
+			throw new Error(`${e.message}: GET /${url} ${JSON.stringify(params)}`);
+		}
+
+		// fires events with the result
+		_bindings.find.forEach(callback => {
+			callback(res.data);
+		});
+
+		return res.data;
+	}
+	/**
+	 * Creates a resource
+	 *
+	 * @param {string} name
+	 * @param {object} data
+	 */
+	async create(data) {
+		let url = `${this._endpoint}/${this._resource}`;
+		var res = await this._api.post(url, data, {
+			validateStatus: (status) => { return true }
+		});
+		switch (res.status) {
+			case 500:
+				throw new Error(`HTTP 500: POST ${url}: ${res.data.type} - ${res.data.message}`);
+		}
+		Object.assign(this, res.data);
+		return res.data;
+	}
+	/**
+	 * Updates a resource
+	 *
+	 * @param {string} name
+	 * @param {object} data
+	 */
+	async update(id = '', data) {
+		let currentId = id || this._id;
+		if (!currentId) {
+			throw new Error("unable to update record without an _id");
+		}
+		let url = `${this._endpoint}/${this._resource}/${currentId}`;
+		var res = await this._api.patch(url, data, {
+			validateStatus: (status) => { return true }
+		});
+		switch (res.status) {
+			case 500:
+				throw new Error(`HTTP 500: PATCH ${url}: ${res.data.type} - ${res.data.message}`);
+			case 400:
+				throw new Error(`HTTP 400: PATCH ${url}: ${res.data.info.message} - ${JSON.stringify(data)}`);
+		}
+		Object.assign(this, res.data);
+		return res.data;
+	}
+	/**
+	 * Reads a resource
+	 *
+	 * @param {string} name
+	 * @param {object} opts
+	 */
+	async read(id = '', opts = {}) {
+		let currentId = id || this._id;
+		if (!currentId) {
+			throw new Error("unable to read record without an _id");
+		}
+		let url = `${this._endpoint}/${this._resource}/${currentId}`;
+		return this._api.get(url, opts).then(res => res.data);
+	}
+	/**
+	 * Deletes a resource
+	 *
+	 * @param {string} name
+	 * @param {string} id
+	 */
+	async delete(id = '') {
+		let currentId = id || this._id;
+		if (!currentId) {
+			throw new Error("unable to delete record without an _id");
+		}
+		let url = `${this._endpoint}/${this._resource}/${id}`;
+		return this._api.delete(url).then(res => res.data);
+	}
+}

package/src/Tag.js

@@ -0,0 +1,11 @@
+import Model from "./Model";
+
+export default class Tag extends Model {
+	constructor(data) {
+		super(data);
+		this._resource = 'tags';
+	}
+	static get _resource() {
+		return 'tags';
+	}
+}