infopark_fiona7 1.5.5.5.1 → 1.6.1.1.0

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

@@ -0,0 +1,209 @@
+'use strict';
+
+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 = 15000;
+  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, requestParams) {
+      return fetch('DELETE', path, requestParams);
+    }
+  };
+
+  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 ajaxParams;
+  }
+
+  function ajax(method, path, requestParams, timeout, token) {
+    // -- PATCH BEGINS HERE --
+    var url = '/_f7/tenants/' + tenant + '/perform';
+    // -- PATCH ENDS HERE --
+    var ajaxParams = prepareAjaxParams(method, path, requestParams);
+
+    // -- PATCH BEGINS HERE --
+    return scrivito.fetch(method, url, ajaxParams, timeout, null);
+    // -- 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)');
+    }
+  }
+})();

data/app/assets/javascripts/scrivito_patches/components/sidebar/workspaces_panel.js

@@ -0,0 +1,325 @@
+"use strict";
+
+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 () {
+  scrivito.Sidebar.WorkspacesPanel = scrivito.createReactClass({
+    propTypes: {
+      isActive: React.PropTypes.bool.isRequired
+    },
+
+    render: function render() {
+      if (!this.props.isActive) {
+        return null;
+      }
+
+      return React.createElement(
+        ReactCustomScrollbars.Scrollbars,
+        {
+          className: "scrivito_second_level_content scrivito_workspaces_panel scrivito_dark" },
+        React.createElement(CurrentWorkspaceGroup, null),
+        React.createElement(OtherWorkspacesGroup, null)
+      );
+    }
+  });
+
+  var GeneralWorkspacesGroup = scrivito.createReactClass({
+    render: function render() {
+      return React.createElement(
+        "div",
+        { className: "scrivito_general_workspaces_group" },
+        React.createElement(
+          "div",
+          { className: "scrivito_sidebar_separator" },
+          React.createElement(
+            "span",
+            null,
+            scrivito.t('sidebar.workspaces_panel.general_workspaces_group.title')
+          )
+        ),
+        React.createElement(
+          "ul",
+          { className: "scrivito_sidebar_action" },
+          React.createElement(CreateWorkspaceButton, null),
+          React.createElement(PublishHistoryButton, null)
+        )
+      );
+    }
+  });
+
+  var CurrentWorkspaceGroup = scrivito.createReactClass({
+    render: function render() {
+      var currentWorkspace = scrivito.Workspace.selected;
+
+      var currentWorkspaceButtons = undefined;
+
+      if (currentWorkspace.isEditable()) {
+        currentWorkspaceButtons = React.createElement(
+          "ul",
+          { className: "scrivito_sidebar_action" },
+          React.createElement(TasksButton, { workspace: currentWorkspace }),
+          React.createElement(ChangesButton, { workspace: currentWorkspace })
+        );
+      }
+
+      return React.createElement(
+        "div",
+        { className: "scrivito_current_workspace_group" },
+        React.createElement(
+          "div",
+          { className: "scrivito_sidebar_separator" },
+          React.createElement(
+            "span",
+            null,
+            scrivito.t('sidebar.workspaces_panel.current_workspace_group.title')
+          )
+        ),
+        React.createElement(scrivito.Sidebar.WorkspaceList, { workspaces: [currentWorkspace], isActive: true }),
+        currentWorkspaceButtons
+      );
+    }
+  });
+
+  var OtherWorkspacesGroup = scrivito.createReactClass({
+    render: function render() {
+      return React.createElement(
+        "div",
+        { className: "scrivito_other_workspaces_group" },
+        React.createElement(
+          "div",
+          { className: "scrivito_sidebar_separator" },
+          React.createElement(
+            "span",
+            null,
+            scrivito.t('sidebar.workspaces_panel.other_workspaces_group.title')
+          )
+        ),
+        React.createElement(OtherWorkspacesList, null)
+      );
+    }
+  });
+
+  var OtherWorkspacesList = scrivito.createReactClass({
+    shouldRenderLoader: true,
+
+    render: function render() {
+      var currentWorkspace = scrivito.Workspace.selected;
+
+      var otherWorkspaces = currentWorkspace.otherEditableWorkspaces;
+
+      if (currentWorkspace.isEditable()) {
+        otherWorkspaces = [scrivito.Workspace.published].concat(_toConsumableArray(otherWorkspaces));
+      }
+
+      return React.createElement(scrivito.Sidebar.WorkspaceList, { workspaces: otherWorkspaces });
+    }
+  });
+
+  var CreateWorkspaceButton = scrivito.createReactClass({
+    render: function render() {
+      return React.createElement(
+        "li",
+        { className: this._buttonClassName(), title: this._buttonHint(),
+          onClick: this._onClick },
+        React.createElement("i", { className: "scrivito_icon scrivito_icon_inv_plus scrivito_green" }),
+        React.createElement(
+          "span",
+          null,
+          scrivito.t('sidebar.workspaces_panel.create_workspace_button.title')
+        )
+      );
+    },
+
+    _onClick: function _onClick(e) {
+      if (this._isEnabled()) {
+        scrivito.create_workspace_command().execute();
+      }
+
+      e.stopPropagation();
+    },
+
+    _buttonClassName: function _buttonClassName() {
+      var className = 'scrivito_create_workspace_button scrivito_sidebar_action_item';
+
+      if (!this._isEnabled()) {
+        className += ' scrivito_disabled';
+      }
+
+      return className;
+    },
+
+    _buttonHint: function _buttonHint() {
+      if (!this._isEnabled()) {
+        return scrivito.t('sidebar.workspaces_panel.create_workspace_button.is_disabled');
+      }
+
+      return scrivito.t('sidebar.workspaces_panel.create_workspace_button.hint');
+    },
+
+    _isEnabled: function _isEnabled() {
+      return scrivito.User.current.can('create');
+    }
+  });
+
+  var PublishHistoryButton = scrivito.createReactClass({
+    render: function render() {
+      return React.createElement(
+        "li",
+        { className: "scrivito_publish_history_button scrivito_sidebar_action_item",
+          title: scrivito.t('sidebar.workspaces_panel.publish_history_button.hint'),
+          onClick: this._onClick },
+        React.createElement("i", { className: "scrivito_icon scrivito_icon_history" }),
+        React.createElement(
+          "span",
+          null,
+          scrivito.t('sidebar.workspaces_panel.publish_history_button.title')
+        )
+      );
+    },
+
+    _onClick: function _onClick(e) {
+      scrivito.PublishHistoryDialog.open();
+      e.stopPropagation();
+    }
+  });
+
+  var ChangesButton = createWorkspaceButtonClass({
+    name: 'changes',
+    icon: 'edited',
+    verb: 'read',
+    onClick: function onClick() {
+      scrivito.openWorkspaceChanges();
+    }
+  });
+
+  var PublishButton = createWorkspaceButtonClass({
+    name: 'publish',
+    verb: 'publish',
+    color: 'green',
+
+    onClick: function onClick(workspace) {
+      var publisher = new scrivito.WorkspacePublisher(workspace);
+      scrivito.publishWorkspace(workspace, publisher);
+    }
+  });
+
+  /* PATCH BEGINS HERE */
+  var TasksButton = createWorkspaceButtonClass({
+    name: 'tasks',
+    icon: 'clipboard',
+    verb: 'read',
+    onClick: function onClick() {
+      scrivito.task_list_dialog.open();
+    }
+  });
+  /* PATCH ENDS HERE */
+
+  var SettingsButton = createWorkspaceButtonClass({
+    name: 'settings',
+    verb: 'invite_to',
+    onClick: function onClick(workspace) {
+      scrivito.openWorkspaceSettings(workspace);
+    }
+  });
+
+  var RebaseButton = createWorkspaceButtonClass({
+    name: 'rebase',
+    icon: 'refresh',
+    verb: 'write',
+
+    isButtonDisabled: function isButtonDisabled(workspace) {
+      return workspace.isAutoUpdate();
+    },
+
+    onClick: function onClick(workspace) {
+      var legacyWorkspace = scrivito.legacy_workspace.fromWorkspace(workspace);
+      scrivito.rebase_workspace_command(legacyWorkspace).execute();
+    }
+  });
+
+  function createWorkspaceButtonClass(_ref) {
+    var name = _ref.name;
+    var icon = _ref.icon;
+    var color = _ref.color;
+    var verb = _ref.verb;
+    var isButtonDisabled = _ref.isButtonDisabled;
+    var onClick = _ref.onClick;
+
+    return scrivito.createReactClass({
+      propTypes: {
+        workspace: React.PropTypes.instanceOf(scrivito.Workspace).isRequired
+      },
+
+      render: function render() {
+        if (isButtonDisabled && isButtonDisabled(this.props.workspace)) {
+          return null;
+        }
+
+        return React.createElement(
+          "li",
+          { className: this._buttonClassName(),
+            title: this._title(),
+            onClick: this._onClick },
+          React.createElement("i", { className: this._iconClassName() }),
+          React.createElement(
+            "span",
+            null,
+            scrivito.t("sidebar.workspaces_panel." + name + "_button.title")
+          )
+        );
+      },
+
+      _buttonClassName: function _buttonClassName() {
+        var className = "scrivito_sidebar_action_item scrivito_" + name + "_button";
+
+        if (!this._canAccessWorkspace()) {
+          className += ' scrivito_disabled';
+        }
+
+        return className;
+      },
+
+      _iconClassName: function _iconClassName() {
+        var className = "scrivito_icon scrivito_icon_" + (icon || name);
+
+        if (color) {
+          className += " scrivito_" + color;
+        }
+
+        return className;
+      },
+
+      _title: function _title() {
+        var localesPrefix = "sidebar.workspaces_panel." + name + "_button";
+
+        if (!this._canAccessWorkspace()) {
+          return scrivito.t(localesPrefix + ".is_forbidden");
+        }
+
+        return scrivito.t(localesPrefix + ".hint");
+      },
+
+      _canAccessWorkspace: function _canAccessWorkspace() {
+        return scrivito.User.current.can(verb, this.props.workspace);
+      },
+
+      _onClick: function _onClick(e) {
+        if (this._canAccessWorkspace()) {
+          onClick(this.props.workspace);
+        }
+
+        e.stopPropagation();
+      }
+    });
+  }
+})();
+/*
+PATCH BEGINS HERE
+<GeneralWorkspacesGroup />
+PATCH ENDS HERE
+*/ /* PATCH BEINGS HERE */ /*
+                           <PublishButton workspace={currentWorkspace} />
+                           <ChangesButton workspace={currentWorkspace }/>
+                           <SettingsButton workspace={currentWorkspace} />
+                           <RebaseButton workspace={currentWorkspace} />
+                           */ /* PATCH ENDS HERE */