infopark_fiona7 1.2.0.1.1 → 1.2.0.1.3

data/app/assets/javascripts/scrivito_patches/models/api/basic_obj.js

@@ -0,0 +1,650 @@
+'use strict';
+
+var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+var _get = function get(_x4, _x5, _x6) { var _again = true; _function: while (_again) { var object = _x4, property = _x5, receiver = _x6; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x4 = parent; _x5 = property; _x6 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+(function () {
+  var SYSTEM_ATTRIBUTES = {
+    _id: 'id',
+    _obj_class: 'objClass',
+    _path: 'path',
+    _permalink: 'permalink',
+    _last_changed: 'lastChanged'
+  };
+
+  /**
+   * The base class for CMS objects.
+   *
+   * A CMS object is a collection of properties and their values, as defined
+   * by its object class.
+   *
+   * @borrows scrivito.AttributeContent#get as #get
+   */
+  scrivito.BasicObj = (function (_scrivito$AttributeContent) {
+    _inherits(BasicObj, _scrivito$AttributeContent);
+
+    _createClass(BasicObj, null, [{
+      key: 'fetch',
+
+      /**
+       * Fetch a given Obj by its `id`.
+       *
+       * @param {string} id - The id of the Obj
+       * @returns {Promise<scrivito.BasicObj>} A promise that resolves to the obj with the given
+       *   id. In case no CMS object with the given `id` exists, the promise is rejected with
+       *   a {@link scrivito.ResourceNotFoundError}.
+       */
+      value: function fetch(id) {
+        scrivito.asyncMethodStub();
+      }
+
+      /**
+       * Get a given Obj by its `id`.
+       *
+       * @param {string} id - The id of the Obj
+       * @throws {scrivito.ResourceNotFoundError} If the CMS object with the given `id`
+       *     does not exists.
+       * @throws {scrivito.NotLoadedError} If the CMS object is not yet loaded.
+       * @returns {scrivito.BasicObj}
+       */
+    }, {
+      key: 'get',
+      value: function get(id) {
+        var objData = scrivito.ObjDataStore.get(id);
+        return new scrivito.BasicObj(objData);
+      }
+
+      /**
+       * Create a new {@link scrivito.BasicObj Obj}.
+       *
+       * @param attributes the new obj's attributes. The `_obj_class` has to be provided
+       *
+       * @return {scrivito.BasicObj} the newly created obj.
+       * @throws {scrivito.ArgumentError} if the `_obj_class` is missing or invalid.
+       */
+    }, {
+      key: 'create',
+      value: function create(attributes) {
+        ensureObjClassExists(attributes._obj_class);
+
+        if (!attributes._id) {
+          attributes._id = this.generateId();
+        }
+
+        return this.createWithSerializedAttributes(_.pick(attributes, '_obj_class', '_id'), attributes);
+      }
+    }, {
+      key: 'createWithDefaults',
+      value: function createWithDefaults(_ref) {
+        var _this = this;
+
+        var _obj_class = _ref._obj_class;
+        var _path = _ref._path;
+
+        var attributes = undefined;
+        if (_path) {
+          attributes = { _path: _path };
+        }
+
+        return scrivito.ObjClass.find(_obj_class).fetchDefaults(attributes).then(function (serializedAttributes) {
+          return _this.createWithSerializedAttributes(serializedAttributes);
+        }).then(function (obj) {
+          return obj.finishSaving().then(function () {
+            return obj;
+          });
+        });
+      }
+    }, {
+      key: 'addChildWithSerializedAttributes',
+      value: function addChildWithSerializedAttributes(parentPath, serializedAttributes) {
+        var objId = scrivito.BasicObj.generateId();
+        var defaultName = serializedAttributes._obj_class || objId; // <-- PATCH HERE
+        return this.createWithSerializedAttributes(_.extend({}, serializedAttributes, {
+          _id: objId,
+          _path: parentPath + '/' + defaultName }));
+      }
+    }, {
+      key: 'createWithSerializedAttributes',
+      // <-- PATCH HERE
+      value: function createWithSerializedAttributes(serializedAttributes, attributeDict) {
+        if (!attributeDict) {
+          return this.createWithSerializedAttributes.apply(this, _toConsumableArray(extractAttributeDict(serializedAttributes)));
+        }
+
+        // -- PATCH BEGINS HERE --
+        if (!serializedAttributes._path) {
+          var page = scrivito.application_document().page();
+          var path = typeof page.provided_path === 'function' && page.provided_path();
+          if (path) {
+            var blobName = undefined;
+            if (serializedAttributes.blob && typeof serializedAttributes.blob === 'object') {
+              blobName = serializedAttributes.blob.name || serializedAttributes.blob.filename;
+            } else {
+              blobName = undefined;
+            }
+            var defaultName = blobName || serializedAttributes._name || serializedAttributes._obj_class || serializedAttributes._id;
+            serializedAttributes._path = path + '/' + defaultName;
+          }
+        }
+        // -- PATCH ENDS HERE --
+
+        var objData = scrivito.ObjDataStore.createObjData(serializedAttributes._id);
+        objData.update(serializedAttributes);
+
+        var obj = new scrivito.BasicObj(objData);
+        obj.update(attributeDict);
+
+        return obj;
+      }
+    }, {
+      key: 'generateId',
+      value: function generateId() {
+        return scrivito.random_id();
+      }
+
+      /**
+       * Returns an {@link scrivito.ObjSearchIterable} of all {@link scrivito.BasicObj}s.
+       * @return {scrivito.ObjSearchIterable}
+       */
+    }, {
+      key: 'all',
+      value: function all() {
+        return new scrivito.ObjSearchIterable().batchSize(1000);
+      }
+
+      /**
+       * Returns an {@link scrivito.ObjSearchIterable} with the given initial subquery consisting
+       * of the four arguments.
+       *
+       * Note that `field` and `value` can also be arrays for searching several fields or searching
+       * for several values. For detailed information see {@link scrivito.ObjSearchIterable}.
+       *
+       * @example
+       * // Look for objects with left-over "Lorem", boosting headline matches:
+       * scrivito.BasicObj.where(:*, :contains, 'Lorem', headline: 2)
+       *
+       * @param {String|String[]} field See {@link scrivito.ObjSearchIterable#and} for details
+       * @param {String} operator See {@link scrivito.ObjSearchIterable#and} for details
+       * @param {String|String[]} value See {@link scrivito.ObjSearchIterable#and} for details
+       * @param {Object} [boost] See {@link scrivito.ObjSearchIterable#and} for details
+       * @return {scrivito.ObjSearchIterable}
+       */
+    }, {
+      key: 'where',
+      value: function where(field, operator, value) {
+        var boost = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3];
+
+        return new scrivito.ObjSearchIterable().and(field, operator, value, boost);
+      }
+
+      /**
+       * Find the {@link scrivito.BasicObj Obj} with the given path.
+       * Returns `null` if no matching Obj exists.
+       * @param {String} path Path of the {@link scrivito.BasicObj Obj}.
+       * @return {scrivito.BasicObj?}
+       * @throws {scrivito.NotLoadedError} If the CMS object is not yet loaded.
+       */
+    }, {
+      key: 'findByPath',
+      value: function findByPath(path) {
+        return scrivito.iterable.firstValueFromIterator(this.where('_path', 'equals', path).iterator());
+      }
+
+      /**
+       * Returns the {@link scrivito.BasicObj Obj} with the given permalink, or `null` if no
+       * matching Obj exists.
+       * @param {String} permalink The permalink of the {@link scrivito.BasicObj Obj}.
+       * @return {scrivito.BasicObj?}
+       * @throws {scrivito.NotLoadedError} If the CMS object is not yet loaded.
+       */
+    }, {
+      key: 'findByPermalink',
+      value: function findByPermalink(permalink) {
+        var iterator = this.where('_permalink', 'equals', permalink).iterator();
+        return scrivito.iterable.firstValueFromIterator(iterator);
+      }
+
+      /**
+       * The constructor is not part of the public API and should **not** be used.
+       *
+       * Please use {@link scrivito.BasicObj.fetch} to access existing CMS objects or
+       * {@link scrivito.BasicObj.create} to create a new one.
+       */
+    }]);
+
+    function BasicObj(objData) {
+      _classCallCheck(this, BasicObj);
+
+      _get(Object.getPrototypeOf(BasicObj.prototype), 'constructor', this).call(this);
+      this.objData = objData;
+    }
+
+    /**
+     * The `id` of the CMS object
+     * @type {String}
+     */
+
+    _createClass(BasicObj, [{
+      key: 'getParent',
+      value: function getParent() {
+        if (this._hasParent()) {
+          return scrivito.BasicObj.findByPath(computeParentPath(this.path));
+        }
+
+        return null;
+      }
+    }, {
+      key: 'hasConflicts',
+      value: function hasConflicts() {
+        return !!this._current._conflicts;
+      }
+    }, {
+      key: 'fetchParent',
+
+      /**
+       * Fetches the {@link scrivito.BasicObj} that is the parent of this Obj.
+       *
+       * @returns {Promise<scrivito.BasicObj>} A promise that resolves to the parent Obj.
+       *   Resolves to `null` if the obj has no parent.
+       */
+      value: function fetchParent() {
+        scrivito.asyncMethodStub();
+      }
+
+      /**
+       * Returns a list of all child {@link scrivito.BasicObj Objs}
+       *
+       * Throws a {@link scrivito.NotLoadedError} if the children are not yet loaded.
+       *
+       * @type {scrivito.BasicObj[]}
+       */
+    }, {
+      key: 'update',
+
+      /**
+       * Updates the attributes of the current CMS object.
+       *
+       * @param {Object} attributes - the new attributes
+       *
+       * @example
+       * // Change the permalink of a CMS object
+       * obj.update({_permalink: '/blog'});
+       *
+       * @example
+       * // Change a string and reorder widgets
+       * obj.update({title: 'New Title', body: obj.get('body').reverse()});
+       */
+      value: function update(attributes) {
+        this._persistWidgets(this, this._objClass, attributes);
+        var patch = scrivito.AttributeSerializer.serialize(this._objClass, attributes);
+        this.objData.update(patch);
+        this._linkResolution.start();
+      }
+    }, {
+      key: 'copyAsync',
+      value: function copyAsync() {
+        var copyOptions = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+        assertValidCopyOptions(copyOptions);
+
+        return this._copyAttributes().then(function (copiedAttributes) {
+          var serializedAttributes = _.extend(copiedAttributes, copyOptions);
+          var obj = scrivito.BasicObj.createWithSerializedAttributes(serializedAttributes);
+          return obj.finishSaving().then(function () {
+            return obj;
+          });
+        });
+      }
+    }, {
+      key: 'moveToAsync',
+      value: function moveToAsync(parentPath) {
+        this.update({ _path: parentPath + '/' + this.id });
+        return this.finishSaving();
+      }
+    }, {
+      key: 'markResolvedAsync',
+      value: function markResolvedAsync() {
+        this.update({ _conflicts: null });
+        return this.finishSaving();
+      }
+
+      /**
+       * Resolves when all previous {@link scrivito.BasicObj#update updates} have been persisted.
+       * If an update fails the promise is rejected.
+       *
+       * @returns {Promise}
+       */
+    }, {
+      key: 'finishSaving',
+      value: function finishSaving() {
+        var _this2 = this;
+
+        var finish = this._linkResolution.finishResolving().then(function () {
+          return _this2.objData.finishSaving();
+        });
+        return new scrivito.PublicPromise(finish);
+      }
+
+      /**
+       * Access widgets by their ids
+       *
+       * @param {String} id - the widget's id
+       * @returns {?scrivito.BasicWidget}
+       */
+    }, {
+      key: 'widget',
+      value: function widget(id) {
+        if (this.widgetData(id)) {
+          return scrivito.BasicWidget.build(id, this);
+        }
+        return null;
+      }
+
+      /**
+       * Returns all widgets of the given CMS object
+       *
+       * @returns {scrivito.BasicWidget[]}
+       */
+    }, {
+      key: 'widgets',
+      value: function widgets() {
+        var _this3 = this;
+
+        return _.map(_.keys(this._widgetPool), function (id) {
+          return _this3.widget(id);
+        });
+      }
+    }, {
+      key: 'widgetData',
+      value: function widgetData(id) {
+        return this._widgetPool[id];
+      }
+    }, {
+      key: 'generateWidgetId',
+      value: function generateWidgetId() {
+        for (var i = 0; i < 10; i++) {
+          var id = scrivito.random_hex();
+
+          if (!this.widget(id)) {
+            return id;
+          }
+        }
+
+        $.error('Could not generate a new unused widget id.');
+      }
+    }, {
+      key: 'serializeAttributes',
+      value: function serializeAttributes() {
+        var serializedAttributes = _get(Object.getPrototypeOf(BasicObj.prototype), 'serializeAttributes', this).call(this);
+
+        delete serializedAttributes._conflicts;
+        delete serializedAttributes._modification;
+        delete serializedAttributes._last_changed;
+
+        return serializedAttributes;
+      }
+    }, {
+      key: '_hasParent',
+      value: function _hasParent() {
+        return this.path && this.path !== '/';
+      }
+    }, {
+      key: '_copyAttributes',
+      value: function _copyAttributes() {
+        var objId = scrivito.BasicObj.generateId();
+        var serializedAttributes = this.serializeAttributes();
+        var uploadPromises = [];
+
+        _.each(serializedAttributes, function (typeAndValue, name) {
+          if (name[0] === '_') {
+            delete serializedAttributes[name];
+            return;
+          }
+
+          var _typeAndValue = _slicedToArray(typeAndValue, 2);
+
+          var type = _typeAndValue[0];
+          var value = _typeAndValue[1];
+
+          if (type === 'binary' && value) {
+            var futureBinary = new scrivito.FutureBinary({ idToCopy: value.id });
+            var promise = futureBinary.into(objId).then(function (binary) {
+              return { name: name, binary: binary };
+            });
+            uploadPromises.push(promise);
+          }
+        });
+
+        serializedAttributes._id = objId;
+        serializedAttributes._obj_class = this.objClass;
+        if (this.path) {
+          serializedAttributes._path = computeParentPath(this.path) + '/' + objId;
+        }
+
+        return scrivito.PublicPromise.all(uploadPromises).then(function (binaries) {
+          _.each(binaries, function (_ref2) {
+            var name = _ref2.name;
+            var binary = _ref2.binary;
+
+            serializedAttributes[name] = ['binary', { id: binary.id }];
+          });
+
+          return serializedAttributes;
+        });
+      }
+    }, {
+      key: 'id',
+      get: function get() {
+        return this._current._id;
+      }
+
+      /**
+       * The object class name of the CMS object
+       * @type {String}
+       */
+    }, {
+      key: 'objClass',
+      get: function get() {
+        return this._current._obj_class;
+      }
+
+      /**
+       * The date the CMS object was last changed.
+       * Returns `null` if the obj has not been changed yet.
+       * @type {?Date}
+       */
+    }, {
+      key: 'lastChanged',
+      get: function get() {
+        if (this._current._last_changed) {
+          return scrivito.parseDate(this._current._last_changed);
+        }
+
+        return null;
+      }
+
+      /**
+       * The path of the CMS object
+       * @type {?String}
+       */
+    }, {
+      key: 'path',
+      get: function get() {
+        return this._current._path || null;
+      }
+
+      /**
+       * The permalink of the CMS object
+       * @type {?String}
+       */
+    }, {
+      key: 'permalink',
+      get: function get() {
+        return this._current._permalink || null;
+      }
+
+      /**
+       * Returns the {@link scrivito.BasicObj} that is the parent of this Obj.
+       * Returns `null` if the obj has no `path` or is the root Obj.
+       *
+       * Throws a {@link scrivito.NotLoadedError} if the parent is not yet loaded.
+       *
+       * @type {?scrivito.BasicObj}
+       */
+    }, {
+      key: 'parent',
+      get: function get() {
+        return this.getParent();
+      }
+    }, {
+      key: 'modification',
+      get: function get() {
+        return this._current._modification || null;
+      }
+    }, {
+      key: 'children',
+      get: function get() {
+        if (this.path) {
+          var iterator = scrivito.BasicObj.where('_parent_path', 'equals', this.path).iterator();
+          return scrivito.iterable.collectValuesFromIterator(iterator);
+        }
+
+        return [];
+      }
+
+      /**
+       * Returns an Array of all the ancestor {@link scrivito.BasicObj Objs}, starting at the
+       * root and ending at the parent of this object.
+       *
+       * Throws a {@link scrivito.NotLoadedError} if the ancestors are not yet loaded.
+       *
+       * @type {scrivito.BasicObj[]}
+       */
+    }, {
+      key: 'ancestors',
+      get: function get() {
+        if (this._hasParent()) {
+          var parentPath = computeParentPath(this.path);
+
+          return collectPathComponents(parentPath).map(function (ancestorPath) {
+            return scrivito.BasicObj.findByPath(ancestorPath);
+          });
+        }
+
+        return [];
+      }
+    }, {
+      key: '_widgetPool',
+      get: function get() {
+        return this._current._widget_pool || {};
+      }
+    }, {
+      key: '_systemAttributes',
+      get: function get() {
+        return SYSTEM_ATTRIBUTES;
+      }
+    }, {
+      key: '_current',
+      get: function get() {
+        return this.objData.current;
+      }
+    }, {
+      key: '_objClass',
+      get: function get() {
+        return scrivito.ObjClass.find(this.objClass);
+      }
+    }, {
+      key: '_linkResolution',
+      get: function get() {
+        return scrivito.LinkResolution['for'](this.objData);
+      }
+    }]);
+
+    return BasicObj;
+  })(scrivito.AttributeContent);
+
+  scrivito.provideAsyncClassMethods(scrivito.BasicObj, {
+    get: 'fetch'
+  });
+
+  scrivito.provideAsyncInstanceMethods(scrivito.BasicObj, {
+    getParent: 'fetchParent'
+  });
+
+  function ensureObjClassExists(objClass) {
+    if (!objClass) {
+      throw new scrivito.ArgumentError('Please provide an obj class as the "_obj_class" property.');
+    }
+
+    if (!scrivito.ObjClass.find(objClass)) {
+      throw new scrivito.ArgumentError('The obj class "' + objClass + '" does not exist.');
+    }
+  }
+
+  function extractAttributeDict(attributes) {
+    var serializedAttributes = {};
+    var attributeDict = {};
+
+    _.each(attributes, function (serializedValue, name) {
+      if (_.isArray(serializedValue) && _.first(serializedValue) === 'widgetlist') {
+        var widgetlist = _.last(serializedValue);
+        attributeDict[name] = _.map(widgetlist, function (serializedWidgetAttributes) {
+          return scrivito.BasicWidget.newWithSerializedAttributes(serializedWidgetAttributes);
+        });
+      } else {
+        serializedAttributes[name] = serializedValue;
+      }
+    });
+
+    if (!serializedAttributes._id) {
+      serializedAttributes._id = scrivito.BasicObj.generateId();
+    }
+
+    return [serializedAttributes, attributeDict];
+  }
+
+  function collectPathComponents(_x7) {
+    var _arguments2 = arguments;
+    var _again2 = true;
+
+    _function2: while (_again2) {
+      var path = _x7;
+      _again2 = false;
+      var results = _arguments2.length <= 1 || _arguments2[1] === undefined ? [] : _arguments2[1];
+
+      if (path === '/') {
+        return ['/'].concat(_toConsumableArray(results));
+      }
+      _arguments2 = [_x7 = computeParentPath(path), [path].concat(_toConsumableArray(results))];
+      _again2 = true;
+      results = undefined;
+      continue _function2;
+    }
+  }
+
+  function computeParentPath(path) {
+    var pathComponents = path.split('/');
+    pathComponents.pop();
+    if (pathComponents.length === 1) {
+      return '/';
+    }
+    return pathComponents.join('/');
+  }
+
+  function assertValidCopyOptions(copyOptions) {
+    var validCopyOptions = ['_path'];
+
+    if (_.difference(_.keys(copyOptions), validCopyOptions).length) {
+      throw new scrivito.ArgumentError('Currently only "_path" copy option is supported.');
+    }
+  }
+})();