infopark_fiona7 1.2.0.2.3 → 1.5.2.0.0

data/app/assets/javascripts/scrivito_patches/base_obj_path.js

@@ -0,0 +1,17 @@
+(function() {
+  _.extend(scrivito, {
+    path_for_id: function(id) {
+      return '/__scrivito/' + id;
+    },
+
+    id_from_path: function(url) {
+      // -- PATCH BEGINS HERE --
+      var match = /__scrivito\/([a-z0-9]{4,})/.exec(url);
+      // -- PATHC ENDS HERE --
+
+      if (match) {
+        return match[1];
+      }
+    }
+  });
+})();

data/app/assets/javascripts/scrivito_patches/binary_utils.js

@@ -0,0 +1,33 @@
+'use strict';
+
+(function () {
+  scrivito.BinaryUtils = {
+    validateBinaryOptions: function validateBinaryOptions(options) {
+      if (_.has(options, 'filename') && !options.filename) {
+        throw new scrivito.ArgumentError('filename cannot be blank');
+      }
+
+      if (_.has(options, 'content_type') && !options.content_type) {
+        throw new scrivito.ArgumentError('content_type cannot be blank');
+      }
+
+      if (_.has(options, 'contentType') && !options.contentType) {
+        throw new scrivito.ArgumentError('contentType cannot be blank');
+      }
+    },
+
+    isBlob: function isBlob(obj) {
+      return !!obj && _.isNumber(obj.size) && _.isString(obj.type);
+    },
+
+    isFile: function isFile(obj) {
+      return this.isBlob(obj) && _.isDate(obj.lastModifiedDate) && _.isString(obj.name);
+    },
+
+    // -- PATCH BEGINS HERE --
+    isBlobWithName: function isBlobWithName(obj) {
+      return typeof obj === 'object' && this.isBlob(obj.blob_to_upload);
+    }
+  };
+})();
+// -- PATCH ENDS HERE --

data/app/assets/javascripts/scrivito_patches/cms_rest_api.js

@@ -0,0 +1,490 @@
+'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; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+(function () {
+  var MIN_REQUEST_TIME = 5;
+  var DEFAULT_REQUEST_TIMEOUT = 120000; // <-- PATCH HERE
+  var backendEndpoint = undefined;
+  var tenant = undefined;
+
+  scrivito.CmsRestApi = {
+    init: function init(endpoint, initTenant) {
+      backendEndpoint = endpoint;
+      tenant = initTenant;
+    },
+
+    get: function get(path, requestParams) {
+      return fetch('GET', path, requestParams);
+    },
+
+    put: function put(path, requestParams) {
+      return fetch('PUT', path, requestParams);
+    },
+
+    post: function post(path, requestParams) {
+      return fetch('POST', path, requestParams);
+    },
+
+    'delete': function _delete(path) {
+      return fetch('DELETE', path);
+    }
+  };
+
+  var Timer = (function () {
+    function Timer() {
+      var timeout = arguments.length <= 0 || arguments[0] === undefined ? DEFAULT_REQUEST_TIMEOUT : arguments[0];
+
+      _classCallCheck(this, Timer);
+
+      this.timesOutAt = Date.now() + timeout;
+    }
+
+    _createClass(Timer, [{
+      key: 'timedOut',
+      value: function timedOut() {
+        return this.remainingTime() < MIN_REQUEST_TIME;
+      }
+    }, {
+      key: 'remainingTime',
+      value: function remainingTime() {
+        return Math.max(this.timesOutAt - Date.now(), 0);
+      }
+    }, {
+      key: 'cover',
+      value: function cover(time) {
+        return time <= this.timesOutAt - MIN_REQUEST_TIME;
+      }
+    }]);
+
+    return Timer;
+  })();
+
+  function fetch(method, path, requestParams) {
+    return request(method, path, requestParams).then(function (result) {
+      if (result && result.task && _.size(result) === 1) {
+        return handleTask(result.task);
+      }
+      return result;
+    });
+  }
+
+  function request(method, path, requestParams) {
+    var timer = new Timer();
+    return retryOnceOnError(timer, method, function () {
+      return retryOnRateLimit(timer, function () {
+        return scrivito.SessionKeeper.performWithToken(function (token) {
+          var ajaxDeferred = ajax(method, path, requestParams, timer.remainingTime(), token);
+          return scrivito.Promise.resolve(ajaxDeferred)['catch'](checkAuthorization);
+        });
+      })['catch'](function (error) {
+        return raiseError(error);
+      });
+    });
+  }
+
+  function retryOnceOnError(timer, method, requestCallback) {
+    if (method === 'POST') {
+      return requestCallback();
+    }
+
+    return requestCallback()['catch'](function (error) {
+      if (!timer.timedOut()) {
+        if (error instanceof scrivito.BackendError) {
+          return requestCallback();
+        }
+        if (error instanceof scrivito.NetworkError) {
+          return requestCallback();
+        }
+      }
+      throw error;
+    });
+  }
+
+  function retryOnRateLimit(timer, requestCallback) {
+    var retry = function retry(retryCount) {
+      return requestCallback()['catch'](function (error) {
+        if (error.status === 429) {
+          var timeout = calculateTimeout(error.getResponseHeader('Retry-After'), retryCount);
+          if (timer.cover(Date.now() + timeout)) {
+            return scrivito.Promise.resolve(scrivito.waitMs(timeout)).then(function () {
+              return retry(retryCount + 1);
+            });
+          }
+          throw new scrivito.RateLimitExceededError('rate limit exceeded', 429);
+        }
+        throw error;
+      });
+    };
+
+    return retry(0);
+  }
+
+  function calculateTimeout(retryAfter, retryCount) {
+    var calculatedTimeout = Math.pow(2, retryCount) * 0.5 * 1000;
+    return Math.max(calculatedTimeout, retryAfter * 1000);
+  }
+
+  function raiseError(error) {
+    if (error.status === undefined || !_.isNumber(error.status)) {
+      throw error;
+    } else if (error.status === 0) {
+      throw new scrivito.NetworkError(error.statusText, error.status);
+    }
+
+    var errorBody = parseError(error);
+    var specificOutput = errorBody.error;
+
+    if (error.status === 403) {
+      throw new scrivito.AccessDeniedError(specificOutput, error.status, errorBody.code);
+    } else if (error.status.toString()[0] === '4' && specificOutput) {
+      throw new scrivito.ClientError(specificOutput, error.status, errorBody.code);
+    } else if (error.status === 500 && specificOutput) {
+      throw new scrivito.BackendError(specificOutput, error.status);
+    }
+    throw new scrivito.NetworkError(error.responseText, error.status);
+  }
+
+  function checkAuthorization(error) {
+    if (error.status === 401) {
+      var errorBody = parseError(error);
+      var specificOutput = errorBody.error;
+      throw new scrivito.UnauthorizedError(specificOutput, error.status, errorBody.code);
+    }
+    throw error;
+  }
+
+  function parseError(error) {
+    try {
+      return JSON.parse(error.responseText);
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        throw new scrivito.NetworkError(error.responseText, error.status);
+      }
+      throw err;
+    }
+  }
+
+  function prepareAjaxParams(method, path) {
+    var requestParams = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+    var ajaxParams = {
+      path: path,
+      verb: method,
+      params: requestParams
+    };
+
+    return {
+      data: JSON.stringify(ajaxParams)
+    };
+  }
+
+  function ajax(method, path, requestParams, timeout, token) {
+    // -- PATCH BEGINS HERE --
+    if (ajaxWithFormDataRequired(requestParams) /* || true */) {
+        return ajaxWithFormData(method, path, requestParams, timeout, token);
+      }
+    // -- PATCH ENDS HERE --
+
+    var ajaxParams = prepareAjaxParams(method, path, requestParams);
+    var ajaxMethod = method === 'POST' ? 'POST' : 'PUT';
+    var url = '/_f7/tenants/' + tenant + '/perform'; // <-- PATCH HERE
+
+    return $.ajax(_.extend({
+      url: url,
+      method: ajaxMethod,
+      contentType: 'application/json; charset=utf-8',
+      dataType: 'json',
+      //headers: { Authorization: `Session ${token}` }, // <-- PATCH HERE
+      timeout: timeout,
+      cache: false, // Don't cache GET requests.
+      xhrFields: { withCredentials: true }
+    }, ajaxParams)).then(function (result, textStatus, xhr) {
+      return $.Deferred().resolve(result);
+    }, function (xhr, textStatus, xhrError) {
+      return $.Deferred().reject(xhr);
+    });
+  }
+
+  // -- PATCH BEGINS HERE --
+  function ajaxWithFormDataRequired(params) {
+    var objParams = params && params.obj;
+    var result = false;
+
+    if (!objParams) {
+      return result;
+    }
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = Object.keys(objParams)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var k = _step.value;
+
+        // if params[k] is an array
+        if (objParams[k].pop) {
+          // file uploads require form data
+          result = scrivito.BinaryUtils.isFile(objParams[k][1]) || scrivito.BinaryUtils.isBlob(objParams[k][1]) || scrivito.BinaryUtils.isBlobWithName(objParams[k][1]);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator['return']) {
+          _iterator['return']();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  function ajaxWithFormData(method, path, requestParams, timeout, token) {
+    var formData = paramsToFormData(method, path, requestParams);
+    var ajaxMethod = method === 'POST' ? 'POST' : 'PUT';
+    var url = '/_f7/tenants/' + tenant + '/perform';
+
+    return $.ajax(_.extend({
+      url: url,
+      method: ajaxMethod,
+      contentType: false,
+      processData: false,
+      data: formData,
+      timeout: timeout,
+      cache: false, // Don't cache GET requests.
+      xhrFields: { withCredentials: true }
+    })).then(function (result, textStatus, xhr) {
+      return $.Deferred().resolve(result);
+    }, function (xhr, textStatus, xhrError) {
+      return $.Deferred().reject(xhr);
+    });
+  }
+
+  function paramsToFormData(verb, path, params) {
+    var objParams = params && params.obj || {};
+    var fd = new FormData();
+    fd.append('verb', verb);
+    fd.append('path', path);
+
+    var _iteratorNormalCompletion2 = true;
+    var _didIteratorError2 = false;
+    var _iteratorError2 = undefined;
+
+    try {
+      for (var _iterator2 = Object.keys(objParams)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var attr = _step2.value;
+
+        // attr is a [type, value] pair
+        if (typeof objParams[attr] === 'object' && objParams[attr].pop) {
+          var _objParams$attr = _slicedToArray(objParams[attr], 2);
+
+          var type = _objParams$attr[0];
+          var value = _objParams$attr[1];
+
+          if (value.pop) {
+            // multienum / stringlist / widgetlist
+            fd.append('params[obj][' + attr + '[]', type);
+            for (var i = 0; i < value.length; ++i) {
+              fd.append('params[obj][' + attr + '[][formdata$workaround][]', value[i]);
+            }
+          } else if (scrivito.BinaryUtils.isFile(value) || scrivito.BinaryUtils.isBlob(value)) {
+            // upload
+            fd.append('params[obj][' + attr + '][]', type);
+            fd.append('params[obj][' + attr + '][]', value);
+          } else if (scrivito.BinaryUtils.isBlobWithName(value)) {
+            fd.append('params[obj][' + attr + '][]', type);
+            fd.append('params[obj][' + attr + '][]', value.blob_to_upload, value.filename);
+          } else if (typeof value === 'object') {
+            // blob/copy rename
+            fd.append('params[obj][' + attr + '[]', type);
+            var _iteratorNormalCompletion3 = true;
+            var _didIteratorError3 = false;
+            var _iteratorError3 = undefined;
+
+            try {
+              for (var _iterator3 = Object.keys(value)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                var l = _step3.value;
+
+                fd.append('params[obj][' + attr + '][][' + l + ']', value[l]);
+              }
+            } catch (err) {
+              _didIteratorError3 = true;
+              _iteratorError3 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion3 && _iterator3['return']) {
+                  _iterator3['return']();
+                }
+              } finally {
+                if (_didIteratorError3) {
+                  throw _iteratorError3;
+                }
+              }
+            }
+          } else if (typeof value !== 'undefined') {
+            fd.append('params[obj][' + attr + '][]', type);
+            fd.append('params[obj][' + attr + '][]', value);
+          }
+          // special handling for widget pool
+        } else if (attr === '_widget_pool') {
+            var value = objParams[attr];
+            var _iteratorNormalCompletion4 = true;
+            var _didIteratorError4 = false;
+            var _iteratorError4 = undefined;
+
+            try {
+              for (var _iterator4 = Object.keys(value)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                var widgetId = _step4.value;
+
+                var widget = value[widgetId];
+                var _iteratorNormalCompletion5 = true;
+                var _didIteratorError5 = false;
+                var _iteratorError5 = undefined;
+
+                try {
+                  for (var _iterator5 = Object.keys(widget)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+                    var widgetAttr = _step5.value;
+
+                    if (widget[widgetAttr].pop) {
+                      var _widget$widgetAttr = _slicedToArray(widget[widgetAttr], 2);
+
+                      var widgetAttrType = _widget$widgetAttr[0];
+                      var widgetValue = _widget$widgetAttr[1];
+
+                      // FIXME: Duplication
+                      if (widgetValue.pop) {
+                        // multienum / stringlist / widgetlist
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetAttrType);
+                        for (var i = 0; i < widgetValue.length; ++i) {
+                          fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][][formdata$workaround][]', widgetValue[i]);
+                        }
+                      } else if (scrivito.BinaryUtils.isFile(widgetValue) || scrivito.BinaryUtils.isBlob(widgetValue)) {
+                        // upload
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetAttrType);
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetValue);
+                      } else if (scrivito.BinaryUtils.isBlobWithName(widgetValue)) {
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetAttrType);
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetValue.blob_to_upload, widgetValue.filename);
+                      } else if (typeof widgetValue === 'object') {
+                        // blob/copy rename
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetAttrType);
+                        var _iteratorNormalCompletion6 = true;
+                        var _didIteratorError6 = false;
+                        var _iteratorError6 = undefined;
+
+                        try {
+                          for (var _iterator6 = Object.keys(widgetValue)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+                            var l = _step6.value;
+
+                            fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][][' + l + ']', widgetValue[l]);
+                          }
+                        } catch (err) {
+                          _didIteratorError6 = true;
+                          _iteratorError6 = err;
+                        } finally {
+                          try {
+                            if (!_iteratorNormalCompletion6 && _iterator6['return']) {
+                              _iterator6['return']();
+                            }
+                          } finally {
+                            if (_didIteratorError6) {
+                              throw _iteratorError6;
+                            }
+                          }
+                        }
+                      } else {
+                        // normal value
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetAttrType);
+                        fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + '][]', widgetValue);
+                      }
+                    } else {
+                      // hopefully a built-in attribute :-)
+                      fd.append('params[obj][' + attr + '][' + widgetId + '][' + widgetAttr + ']', widget[widgetAttr]);
+                    }
+                  }
+                } catch (err) {
+                  _didIteratorError5 = true;
+                  _iteratorError5 = err;
+                } finally {
+                  try {
+                    if (!_iteratorNormalCompletion5 && _iterator5['return']) {
+                      _iterator5['return']();
+                    }
+                  } finally {
+                    if (_didIteratorError5) {
+                      throw _iteratorError5;
+                    }
+                  }
+                }
+              }
+            } catch (err) {
+              _didIteratorError4 = true;
+              _iteratorError4 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion4 && _iterator4['return']) {
+                  _iterator4['return']();
+                }
+              } finally {
+                if (_didIteratorError4) {
+                  throw _iteratorError4;
+                }
+              }
+            }
+          } else {
+            // hopefully a built-in attribute :-)
+            fd.append('params[obj][' + attr + ']', objParams[attr]);
+          }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2['return']) {
+          _iterator2['return']();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+
+    return fd;
+  }
+
+  // -- PATCH ENDS HERE --
+
+  function handleTask(task) {
+    switch (task.status) {
+      case 'success':
+        return task.result;
+      case 'error':
+        throw new scrivito.ClientError(task.message, undefined, task.code);
+      case 'open':
+        return scrivito.wait(2).then(function () {
+          return request('GET', 'tasks/' + task.id).then(function (result) {
+            return handleTask(result);
+          });
+        });
+      default:
+        throw new scrivito.ScrivitoError('Invalid task response (unknown status)');
+    }
+  }
+})();