@pixwel/pixwel-sdk 2.1.4 → 2.1.6

package/dist/IngestFile.js

@@ -0,0 +1,18 @@
+"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 IngestFile = function IngestFile(file, order) {
+  (0, _classCallCheck2["default"])(this, IngestFile);
+  this.file = file;
+} // renderedName, ingest, options
+;
+
+exports["default"] = IngestFile;

package/dist/Model.js

@@ -0,0 +1,580 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _lodash = _interopRequireWildcard(require("lodash"));
+
+var _index = require("../index");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _deepObjectDiff = require("deep-object-diff");
+
+var _validate = _interopRequireDefault(require("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["default"].create({
+    baseURL: _index.Pixwel.endpoint,
+    headers: {
+      Authorization: "Basic ".concat(_index.Pixwel.credentials.token),
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    }
+  });
+}
+
+var Model =
+/*#__PURE__*/
+function () {
+  function Model(data) {
+    (0, _classCallCheck2["default"])(this, Model);
+    Object.assign(this, data);
+    this._endpoint = _index.Pixwel.endpoint;
+    this._api = connection();
+    this._lastState = {};
+    this._validationErrors = [];
+    this._constraints = {};
+  }
+  /**
+   * Adds a validation contraint
+   *
+   * @param {string} name 
+   * @param {object} data 
+   */
+
+
+  (0, _createClass2["default"])(Model, [{
+    key: "addConstraint",
+    value: function addConstraint(name, data) {
+      this._constraints[name] = data;
+    }
+    /**
+     * Validates models data against its contraints
+     */
+
+  }, {
+    key: "validates",
+    value: function validates() {
+      var res = (0, _validate["default"])(this.data(), this._constraints);
+
+      if (res == undefined) {
+        this._validationErrors = [];
+      } else {
+        this._validationErrors = res;
+      }
+
+      return res == undefined ? true : false;
+    }
+  }, {
+    key: "errors",
+    value: function errors() {
+      return this._validationErrors;
+    }
+    /**
+     * Makes a request to the API
+     *
+     * @param {object} config
+     */
+
+  }, {
+    key: "request",
+    value: function () {
+      var _request = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee(config) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", this._api.request(config));
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function request(_x) {
+        return _request.apply(this, arguments);
+      }
+
+      return request;
+    }()
+    /**
+     * Returns data
+     */
+
+  }, {
+    key: "data",
+    value: function data() {
+      var _this = this;
+
+      var keys = Object.keys(this).filter(function (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');
+      var data = {};
+      keys.forEach(function (key) {
+        data[key] = _this[key];
+      });
+      return data;
+    }
+    /**
+     * Register a callback to a model method
+     *
+     * @param {string} method
+     * @param {function} callback
+     */
+
+  }, {
+    key: "save",
+
+    /**
+     * Creates or updates a resource depennding on the presence
+     * of _id
+     *
+     * @param {object} data
+     */
+    value: function () {
+      var _save = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee2() {
+        var _this2 = this;
+
+        var data,
+            input,
+            inputDiff,
+            _args2 = arguments;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                data = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
+                input = data.length ? data : this.data();
+
+                if (!input._id) {
+                  _context2.next = 9;
+                  break;
+                }
+
+                inputDiff = (0, _deepObjectDiff.diff)(this._lastState, input);
+                _context2.next = 6;
+                return this.update(input._id, inputDiff);
+
+              case 6:
+                this._lastState = _context2.sent;
+                _context2.next = 12;
+                break;
+
+              case 9:
+                _context2.next = 11;
+                return this.create(input);
+
+              case 11:
+                this._lastState = _context2.sent;
+
+              case 12:
+                // fires events with the result
+                _bindings.save.forEach(function (callback) {
+                  callback(_this2._lastState);
+                });
+
+                return _context2.abrupt("return", this._lastState);
+
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function save() {
+        return _save.apply(this, arguments);
+      }
+
+      return save;
+    }()
+    /**
+     * Merges incoming data into the model data
+     *
+     * @param {object} data
+     */
+
+  }, {
+    key: "set",
+    value: function set(data) {
+      return _lodash["default"].merge(this, data);
+    }
+    /**
+     * Returns a deep clone of the current object
+     */
+
+  }, {
+    key: "clone",
+    value: function clone() {
+      return (0, _lodash.cloneDeep)(this);
+    }
+    /**
+     * Fetches all objects in a collection given params
+     *
+     * @param {object} params
+     */
+
+  }, {
+    key: "create",
+
+    /**
+     * Creates a resource
+     *
+     * @param {string} name
+     * @param {object} data
+     */
+    value: function () {
+      var _create = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee3(data) {
+        var url, res;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                url = "".concat(this._endpoint, "/").concat(this._resource);
+                _context3.next = 3;
+                return this._api.post(url, data, {
+                  validateStatus: function validateStatus(status) {
+                    return true;
+                  }
+                });
+
+              case 3:
+                res = _context3.sent;
+                _context3.t0 = res.status;
+                _context3.next = _context3.t0 === 500 ? 7 : 8;
+                break;
+
+              case 7:
+                throw new Error("HTTP 500: POST ".concat(url, ": ").concat(res.data.type, " - ").concat(res.data.message));
+
+              case 8:
+                Object.assign(this, res.data);
+                return _context3.abrupt("return", res.data);
+
+              case 10:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function create(_x2) {
+        return _create.apply(this, arguments);
+      }
+
+      return create;
+    }()
+    /**
+     * Updates a resource
+     *
+     * @param {string} name
+     * @param {object} data
+     */
+
+  }, {
+    key: "update",
+    value: function () {
+      var _update = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee4() {
+        var id,
+            data,
+            currentId,
+            url,
+            res,
+            _args4 = arguments;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                id = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : '';
+                data = _args4.length > 1 ? _args4[1] : undefined;
+                currentId = id || this._id;
+
+                if (currentId) {
+                  _context4.next = 5;
+                  break;
+                }
+
+                throw new Error("unable to update record without an _id");
+
+              case 5:
+                url = "".concat(this._endpoint, "/").concat(this._resource, "/").concat(currentId);
+                _context4.next = 8;
+                return this._api.patch(url, data, {
+                  validateStatus: function validateStatus(status) {
+                    return true;
+                  }
+                });
+
+              case 8:
+                res = _context4.sent;
+                _context4.t0 = res.status;
+                _context4.next = _context4.t0 === 500 ? 12 : _context4.t0 === 400 ? 13 : 14;
+                break;
+
+              case 12:
+                throw new Error("HTTP 500: PATCH ".concat(url, ": ").concat(res.data.type, " - ").concat(res.data.message));
+
+              case 13:
+                throw new Error("HTTP 400: PATCH ".concat(url, ": ").concat(res.data.info.message, " - ").concat(JSON.stringify(data)));
+
+              case 14:
+                Object.assign(this, res.data);
+                return _context4.abrupt("return", res.data);
+
+              case 16:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function update() {
+        return _update.apply(this, arguments);
+      }
+
+      return update;
+    }()
+    /**
+     * Reads a resource
+     *
+     * @param {string} name
+     * @param {object} opts
+     */
+
+  }, {
+    key: "read",
+    value: function () {
+      var _read = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee5() {
+        var id,
+            opts,
+            currentId,
+            url,
+            _args5 = arguments;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                id = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : '';
+                opts = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : {};
+                currentId = id || this._id;
+
+                if (currentId) {
+                  _context5.next = 5;
+                  break;
+                }
+
+                throw new Error("unable to read record without an _id");
+
+              case 5:
+                url = "".concat(this._endpoint, "/").concat(this._resource, "/").concat(currentId);
+                return _context5.abrupt("return", this._api.get(url, opts).then(function (res) {
+                  return res.data;
+                }));
+
+              case 7:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function read() {
+        return _read.apply(this, arguments);
+      }
+
+      return read;
+    }()
+    /**
+     * Deletes a resource
+     *
+     * @param {string} name
+     * @param {string} id
+     */
+
+  }, {
+    key: "delete",
+    value: function () {
+      var _delete2 = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee6() {
+        var id,
+            currentId,
+            url,
+            _args6 = arguments;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                id = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : '';
+                currentId = id || this._id;
+
+                if (currentId) {
+                  _context6.next = 4;
+                  break;
+                }
+
+                throw new Error("unable to delete record without an _id");
+
+              case 4:
+                url = "".concat(this._endpoint, "/").concat(this._resource, "/").concat(id);
+                return _context6.abrupt("return", this._api["delete"](url).then(function (res) {
+                  return res.data;
+                }));
+
+              case 6:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function _delete() {
+        return _delete2.apply(this, arguments);
+      }
+
+      return _delete;
+    }()
+  }], [{
+    key: "registerCallback",
+    value: function registerCallback(method, callback) {
+      _bindings[method].push(callback);
+    }
+  }, {
+    key: "all",
+    value: function all() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.find(params);
+    }
+    /**
+     * Finds an object or collection of objects
+     *
+     * @param {object} params
+     */
+
+  }, {
+    key: "find",
+    value: function () {
+      var _find = (0, _asyncToGenerator2["default"])(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee7() {
+        var params,
+            api,
+            url,
+            id,
+            res,
+            _args7 = arguments;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                params = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : {};
+                api = connection();
+
+                if (typeof params === 'string') {
+                  id = params;
+                  url = "".concat(this._resource, "/").concat(id);
+                  params = {};
+                } else {
+                  url = this._resource;
+                }
+
+                _context7.prev = 3;
+                _context7.next = 6;
+                return api.get(url, {
+                  params: params
+                });
+
+              case 6:
+                res = _context7.sent;
+                _context7.next = 12;
+                break;
+
+              case 9:
+                _context7.prev = 9;
+                _context7.t0 = _context7["catch"](3);
+                throw new Error("".concat(_context7.t0.message, ": GET /").concat(url, " ").concat(JSON.stringify(params)));
+
+              case 12:
+                // fires events with the result
+                _bindings.find.forEach(function (callback) {
+                  callback(res.data);
+                });
+
+                return _context7.abrupt("return", res.data);
+
+              case 14:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this, [[3, 9]]);
+      }));
+
+      function find() {
+        return _find.apply(this, arguments);
+      }
+
+      return find;
+    }()
+  }]);
+  return Model;
+}();
+
+exports["default"] = Model;

package/dist/Order.js

@@ -0,0 +1,70 @@
+"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 _lodash = _interopRequireDefault(require("lodash"));
+
+var _Filename = _interopRequireDefault(require("./Filename.js"));
+
+var Order =
+/*#__PURE__*/
+function () {
+  function Order(data) {
+    (0, _classCallCheck2["default"])(this, Order);
+    var schema = {
+      _id: null,
+      asset: null,
+      project: null,
+      assetType: null,
+      country: null,
+      language: null,
+      dng: null
+    };
+    Object.assign(this, schema, data);
+  }
+  /**
+   * Determines if an order should be classified as 'dubbed' based on its dng values
+   */
+
+
+  (0, _createClass2["default"])(Order, [{
+    key: "isDub",
+    value: function isDub() {
+      if (!this.dng) {
+        return null;
+      }
+
+      if (this.dng.graphics && this.dng.graphics.includes('Dedicated / Localized')) {
+        return false;
+      }
+
+      return _lodash["default"].flattenDeep(Object.entries(this.dng)).includes("Dedicated / Localized");
+    }
+    /**
+     * Determines in an order should be classified as 'subbed' based on its dng values
+     */
+
+  }, {
+    key: "isSub",
+    value: function isSub() {
+      if (!this.dng) {
+        return null;
+      }
+
+      if (this.dng === 'Graphics Only') return false;
+      return _lodash["default"].flattenDeep(Object.entries(this.dng)).includes("Subtitled");
+    }
+  }]);
+  return Order;
+}();
+
+exports["default"] = Order;