@pixwel/pixwel-sdk 2.1.4 → 2.1.6

package/dist/Ingest.js

@@ -0,0 +1,734 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _File = _interopRequireDefault(require("./File"));
+
+var _Model2 = _interopRequireDefault(require("./Model"));
+
+var _fileType = require("./fileType");
+
+var _ramda = require("ramda");
+
+/**
+ * [media description]
+ * @type {[type]}
+ */
+var Ingest =
+/*#__PURE__*/
+function (_Model) {
+  (0, _inherits2["default"])(Ingest, _Model);
+
+  function Ingest(data) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, Ingest);
+    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(Ingest).call(this, data));
+    _this._resource = "ingests";
+    return _this;
+  }
+
+  (0, _createClass2["default"])(Ingest, [{
+    key: "renderPath",
+
+    /**
+     * Returns path given an ingest record
+     *
+     */
+    value: function renderPath() {
+      var 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
+     */
+
+  }, {
+    key: "renderFilename",
+    value: function renderFilename() {
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : params = {},
+          allTags = _ref.allTags,
+          allTypes = _ref.allTypes,
+          order = _ref.order;
+
+      var asset = this.data().asset;
+      var options = this.data().selected.download;
+      var 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");
+      }
+
+      var 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 = _lodash["default"].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;
+        }
+
+        var matchingType = _lodash["default"].find(types, {
+          name: asset.type
+        });
+
+        if (!matchingType) {
+          throw new Error("Asset type \"".concat(asset.type, "\" could not be found"));
+        }
+
+        return matchingType.file || matchingType.name.replace(".", "-").toUpperCase();
+      }
+
+      function assetTitle(asset) {
+        var prefix = "";
+        var 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) {
+        var matches = asset.type.match(/^film-clip|^featurette/);
+
+        if (!matches) {
+          return;
+        }
+
+        var minutes = Math.floor(asset.length / 60);
+        var seconds = asset.length % 60;
+        var 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(function (str) {
+          return !!str && str !== "WW";
+        }).join("-");
+      }
+
+      function textType(subDub, text) {
+        if (!subDub || !subDub.sub && !subDub.dub) {
+          return text;
+        }
+
+        var result = [];
+
+        if (subDub.sub) {
+          result.push("sub");
+        }
+
+        if (subDub.dub) {
+          result.push("dub");
+        }
+
+        return result;
+      }
+
+      function matchSet(allTags, tags) {
+        var selectedTags = (0, _lodash["default"])(tags).values().flatten().value();
+        var setTag = (0, _lodash["default"])(allTags).filter("set").find(function (setTag) {
+          return _lodash["default"].difference(setTag.set, selectedTags).length === 0;
+        });
+
+        if (setTag) {
+          return setTag.name;
+        }
+      }
+
+      var 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 = (0, _lodash["default"])(parts).flatten().filter().map(function (part) {
+        return part.toUpperCase();
+      });
+      var matchedSet = matchSet(allTags, options.tags);
+      var 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);
+      }
+
+      var name = parts.join("_");
+      var hasResInfo = name.match(/\d+(i|p)/i);
+      var hasAllInfo = name.match(/\d+(i|p)\d+/i);
+
+      if (requiredInfo && !hasResInfo && !hasAllInfo) {
+        var res = tags.Resolution;
+        var 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(function (val) {
+          return val;
+        }).join("");
+        var 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
+     */
+
+  }, {
+    key: "mediaType",
+    value: function mediaType() {
+      return this.src.mediaType;
+    }
+    /**
+     * Maps mediainfo metadata into ingest Tag format
+     *
+     */
+
+  }, {
+    key: "mapFromMediainfo",
+    value: function mapFromMediainfo() {
+      var info = this.mediainfo;
+      var mediaType = this.source.mediaType;
+      var schema = {
+        Aspect: null,
+        Standard: null,
+        Resolution: null,
+        Codec: null,
+        "Frame Mode": null,
+        Text: null,
+        Usage: null,
+        Extra: [],
+        Framerate: null,
+        Duration: null
+      };
+      var tags = {};
+
+      if (!info.File) {
+        throw "missing info.File";
+      }
+
+      if (!info.File.track) {
+        throw "missing info.File.track";
+      }
+
+      var general;
+
+      if (!Array.isArray(info["File"]["track"])) {
+        general = info["File"]["track"];
+      } else {
+        general = _lodash["default"].find(info["File"]["track"], {
+          _type: "General"
+        });
+      }
+
+      switch (mediaType) {
+        case "video":
+          mediaType = "Video";
+          break;
+
+        case "image":
+          mediaType = "Image";
+          break;
+
+        default:
+          if (general.Format && general.Format == "MXF") {
+            tags.Usage = "broadcast";
+          }
+
+          return tags;
+      }
+
+      var mediainfoDefaults = {
+        DisplayAspectRatio: "",
+        Format: "",
+        Standard: "",
+        Height: "",
+        Width: "",
+        FrameRate: "",
+        ScanType: ""
+      };
+
+      var media = _lodash["default"].find(info["File"]["track"], {
+        _type: mediaType
+      });
+
+      media = _lodash["default"].merge({}, mediainfoDefaults, media);
+      var width = parseInt(media["Width"].replace(" ", "").match(/[0-9 ]+/));
+      var height = parseInt(media["Height"].replace(" ", "").match(/[0-9 ]+/));
+      var Resolution = width && height ? "".concat(width, "x").concat(height) : null;
+
+      if (Resolution) {
+        tags.Resolution = Resolution;
+      }
+
+      var Standard = media["Standard"] ? media["Standard"].toLowerCase() : null;
+
+      if (Standard) {
+        tags.Standard = Standard;
+      }
+
+      var 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) {
+        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;
+        }
+      }
+
+      var 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";
+      }
+
+      if (tags.Codec == "prores") {
+        tags.Usage = "broadcast";
+      }
+
+      if (general && general["Format"] == "MXF") {
+        tags.Usage = "broadcast";
+      }
+
+      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;
+      }
+
+      var ScanType = media["ScanType"].toLowerCase() || null;
+
+      if (ScanType) {
+        tags["Frame Mode"] = ScanType;
+      }
+
+      var ingest = {
+        selected: {
+          download: {
+            tags: tags
+          }
+        }
+      };
+      return ingest;
+    }
+    /**
+     * Maps parsed filename data to a partial ingest record for later merging
+     * @param {*} filename
+     * @param {*} allTags
+     */
+
+  }, {
+    key: "mapFromFilename",
+    value: function mapFromFilename(params) {
+      var allTags = params.allTags;
+      var filename = this.filename;
+      var tags = {
+        SubDub: {
+          sub: null,
+          dub: null
+        }
+      };
+      filename.file.tags.forEach(function (tag) {
+        var foundTag = _lodash["default"].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;
+      var 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;
+    }
+    /**
+     * Create a File from an Ingest object
+     *
+     * @param {object} params
+     */
+
+  }, {
+    key: "createFile",
+    value: function createFile(params) {
+      var allTags = params.allTags,
+          allTypes = params.allTypes,
+          order = params.order;
+      var filename = this.mapFromFilename({
+        allTags: allTags
+      });
+      var mediainfo = this.mapFromMediainfo();
+      var ingest = this.assemble({
+        filename: filename,
+        mediainfo: mediainfo,
+        order: order
+      });
+      var file = new _File["default"]({
+        name: this.renderFilename({
+          allTags: allTags,
+          allTypes: 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
+     */
+
+  }, {
+    key: "assemble",
+    value: function assemble(params) {
+      var filename = params.filename,
+          mediainfo = params.mediainfo,
+          order = params.order,
+          _params$watermarks = params.watermarks,
+          watermarks = _params$watermarks === void 0 ? [] : _params$watermarks;
+      var original = this.data();
+      var defaults = {
+        workRequest: order._id,
+        selected: {
+          download: {
+            enabled: true,
+            tags: {
+              Extra: []
+            },
+            embargo: {
+              enabled: false
+            }
+          },
+          preview: {
+            enabled: false,
+            revision: "Final",
+            type: "none",
+            embargo: {
+              enabled: false
+            }
+          },
+          thumbnail: {
+            enabled: false,
+            position: 50
+          }
+        }
+      };
+
+      var ingest = _lodash["default"].merge(defaults, filename, original, 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 : "";
+      var 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;
+    }
+  }], [{
+    key: "_resource",
+    get: function get() {
+      return "ingests";
+    }
+  }]);
+  return Ingest;
+}(_Model2["default"]);
+/**
+ * Flattens ingest.selected.download.tags into a simple array
+ *
+ * @param {object} data
+ */
+
+
+exports["default"] = Ingest;
+
+function flatValues(data) {
+  var copy = (0, _ramda.clone)(data);
+
+  if (copy.SubDub) {
+    copy.SubDub = (0, _ramda.keys)((0, _ramda.filter)(function (val) {
+      return !!val;
+    }, copy.SubDub));
+  }
+
+  return (0, _ramda.flatten)((0, _ramda.values)(copy));
+}