@plone/volto 18.0.0-alpha.43 → 18.0.0-alpha.44

package/dist/server/assets/UndoControlpanel-CfSOfvIf.js

@@ -0,0 +1,690 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { Component } from "react";
+import PropTypes from "prop-types";
+import { connect } from "react-redux";
+import { compose } from "redux";
+import { Link } from "react-router-dom";
+import { createPortal } from "react-dom";
+import { Container, Segment, Table, Input, Menu } from "semantic-ui-react";
+import { injectIntl, defineMessages, FormattedMessage } from "react-intl";
+import { bX as GET_TRANSACTIONS, bY as REVERT_TRANSACTIONS, T as Toast, H as HelmetExport, F as Form, I as Icon, au as paginationLeftSVG, ai as paginationRightSVG, o as backSVG } from "../entry-server.js";
+import { T as Toolbar } from "./Toolbar-DVsVq7NQ.js";
+import { map } from "lodash-es";
+import { u as undoSVG } from "./undo-lQM6Vhc7.js";
+import { toast } from "react-toastify";
+import "classnames";
+import "moment";
+import "react-router";
+import "react-router-hash-link";
+import "tlds";
+import "prepend-http";
+import "lodash-move";
+import "react-dom/server";
+import "react-transition-group";
+import "promise-file-reader";
+import "uuid";
+import "pretty-bytes";
+import "react-side-effect";
+import "github-slugger";
+import "slate";
+import "hoist-non-react-statics";
+import "query-string";
+import "slate-react";
+import "prettier/standalone";
+import "prettier/parser-html";
+import "prismjs/components/prism-core.js";
+import "react-animate-height";
+import "react-popper";
+import "react-sortable-hoc";
+import "react-dates/initialize.js";
+import "react-anchor-link-smooth-scroll";
+import "jwt-decode";
+import "react-router-config";
+import "react-fast-compare";
+import "object-assign";
+import "lodash-es/split.js";
+import "lodash-es/join.js";
+import "lodash-es/trim.js";
+import "react-cookie";
+import "react-intl-redux";
+import "universal-cookie";
+import "slate-hyperscript";
+import "is-hotkey";
+import "react-dropzone";
+import "react-intersection-observer";
+import "is-url";
+import "lodash-es/isUndefined.js";
+import "lodash-es/isString.js";
+import "redux-mock-store";
+import "serialize-javascript";
+import "superagent";
+import "connected-react-router";
+import "react-beautiful-dnd";
+import "detect-browser";
+import "locale";
+import "history";
+import "redux-thunk";
+import "redux-localstorage-simple";
+import "debug";
+import "express";
+import "http-proxy-middleware";
+import "./users-BY0qskQF.js";
+import "./User-CeYa32LY.js";
+import "./PersonalInformation--cOokZv2.js";
+function getTransactions() {
+  return {
+    type: GET_TRANSACTIONS,
+    request: {
+      op: "get",
+      path: `/@transactions`
+    }
+  };
+}
+function revertTransactions(transaction_ids) {
+  return {
+    type: REVERT_TRANSACTIONS,
+    request: {
+      op: "patch",
+      path: "/@transactions",
+      data: { transaction_ids }
+    }
+  };
+}
+const messages = defineMessages({
+  success: {
+    id: "Success",
+    defaultMessage: "Success"
+  },
+  error: {
+    id: "Error",
+    defaultMessage: "Error"
+  },
+  undo: {
+    id: "Undo",
+    defaultMessage: "Undo"
+  },
+  back: {
+    id: "Back",
+    defaultMessage: "Back"
+  },
+  default: {
+    id: "Default",
+    defaultMessage: "Default"
+  },
+  sortBy: {
+    id: "Sort By",
+    defaultMessage: "Sort by"
+  },
+  sorted: {
+    id: "Sorted",
+    defaultMessage: "Sorted"
+  },
+  unsorted: {
+    id: "Unsorted",
+    defaultMessage: "Unsorted"
+  },
+  sortByDescription: {
+    id: "Sort transactions by User-Name, Path or Date",
+    defaultMessage: "Sort transactions by User-Name, Path or Date"
+  },
+  failedToUndoTransactions: {
+    id: "Failed To Undo Transactions",
+    defaultMessage: "Failed to undo transactions"
+  },
+  successfullyUndoneTransactions: {
+    id: "Successfully Undone Transactions",
+    defaultMessage: "Successfully undone transactions"
+  },
+  transactionsHaveBeenSorted: {
+    id: "Transactions Have Been Sorted",
+    defaultMessage: "Transactions have been sorted"
+  },
+  transactionsHaveBeenUnsorted: {
+    id: "Transactions Have Been Unsorted",
+    defaultMessage: "Transactions have been unsorted"
+  },
+  noTransactionsSelected: {
+    id: "No Transactions Selected",
+    defaultMessage: "No transactions selected"
+  },
+  noTransactionsSelectedToDoUndo: {
+    id: "No Transactions Selected To Do Undo",
+    defaultMessage: "No transactions selected to do undo"
+  }
+});
+class UndoControlpanel extends Component {
+  /**
+   * Constructor
+   * @method constructor
+   * @param {Object} props Component properties
+   * @constructs UndoControlpanel
+   */
+  constructor(props) {
+    super(props);
+    this.state = {
+      isClient: false,
+      sortType: "no value",
+      lowerIndex: 0,
+      upperIndex: 20,
+      defaultTransactionsLenInTable: 20,
+      isSortingTypeSelected: false,
+      sortedTransactions: [],
+      isEmptyInputForSorting: false,
+      isTransactionsNotFound: false,
+      isClickedOnUndoButton: false,
+      showPrevButton: false,
+      showNextButton: false
+    };
+    this.onCancel = this.onCancel.bind(this);
+    this.onSort = this.onSort.bind(this);
+    this.onSelect = this.onSelect.bind(this);
+    this.onPrev = this.onPrev.bind(this);
+    this.onNext = this.onNext.bind(this);
+    this.onUndo = this.onUndo.bind(this);
+    this.handleTableVisiblity = this.handleTableVisiblity.bind(this);
+    this.handleNotSortedNextPrevButtons = this.handleNotSortedNextPrevButtons.bind(this);
+    this.handleSortedNextPrevButtons = this.handleSortedNextPrevButtons.bind(this);
+    this.checkTransactionsUndoneStatus = this.checkTransactionsUndoneStatus.bind(this);
+  }
+  /**
+   * Component did mount
+   * @method componentDidMount
+   * @returns {undefined}
+   */
+  componentDidMount() {
+    this.setState({
+      isClient: true
+    });
+    this.props.getTransactions();
+  }
+  /**
+   * Component will receive props
+   * @method componentWillReceiveProps
+   * @param {Object} nextProps Next properties
+   * @returns {undefined}
+   */
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    if (this.props.revertRequest.loading && nextProps.revertRequest.loaded) {
+      this.props.getTransactions();
+    }
+  }
+  setSortedTransactions(sortedTransactions) {
+    if (sortedTransactions.length > 0) {
+      this.setState({
+        lowerIndex: 0,
+        upperIndex: this.state.defaultTransactionsLenInTable,
+        sortedTransactions,
+        isEmptyInputForSorting: false,
+        isTransactionsNotFound: false
+      });
+    } else {
+      this.setState({ isTransactionsNotFound: true });
+    }
+  }
+  /**
+   * On Cancel
+   * @method onCancel
+   * @returns {undefined}
+   */
+  onCancel() {
+    if (this.state.sortedTransactions.length > 0) {
+      toast.info(
+        /* @__PURE__ */ jsx(
+          Toast,
+          {
+            info: true,
+            title: this.props.intl.formatMessage(messages.unsorted),
+            content: this.props.intl.formatMessage(
+              messages.transactionsHaveBeenUnsorted
+            )
+          }
+        )
+      );
+    }
+    this.setState({
+      isSortingTypeSelected: false,
+      isTransactionsNotFound: false,
+      isEmptyInputForSorting: false,
+      sortType: "no value",
+      sortedTransactions: [],
+      lowerIndex: 0,
+      upperIndex: this.state.defaultTransactionsLenInTable
+    });
+  }
+  /**
+   * On Select
+   * @method onSelect
+   * @param {object} data
+   * @returns {undefined}
+   */
+  onSelect(data) {
+    if (data !== null && data.sortingTypes !== null && this.state.sortType.toLowerCase() === data.sortingTypes.toLowerCase()) {
+      return;
+    }
+    let sortType = data !== null && data.sortingTypes || "no value";
+    if (sortType.toLowerCase() !== "no value") {
+      this.setState({ isSortingTypeSelected: true });
+      sortType.toLowerCase() === "user name" && this.setState({ sortType: "user name" });
+      sortType.toLowerCase() === "date" && this.setState({ sortType: "date" });
+      sortType.toLowerCase() === "path" && this.setState({ sortType: "path" });
+    } else {
+      this.onCancel();
+    }
+  }
+  /**
+   * On Sort
+   * @method onSort
+   * @param {object} data
+   * @returns {undefined}
+   */
+  onSort(data) {
+    let sortType = data.sortingTypes || "no value";
+    let value;
+    sortType.toLowerCase() === "user name" && (value = data.sortByUsername) || sortType.toLowerCase() === "path" && (value = data.sortByPath) || sortType.toLowerCase() === "date" && (value = data.sortByDate) || (value = void 0);
+    if (sortType.toLowerCase() !== "no value" && value !== void 0) {
+      let sortedTransactions = [];
+      if (sortType.toLowerCase() === "user name") {
+        this.props.transactions.forEach((element) => {
+          if (value.trim().toLowerCase() === "zope" && !element.username) {
+            sortedTransactions.push(element);
+          } else if (element.username.trim().toLowerCase().includes(value.trim().toLowerCase())) {
+            sortedTransactions.push(element);
+          }
+        });
+        this.setSortedTransactions(sortedTransactions);
+      } else if (sortType.toLowerCase() === "path") {
+        this.props.transactions.forEach((element) => {
+          if (element.id.trim().toLowerCase().includes(value.trim().toLowerCase())) {
+            sortedTransactions.push(element);
+          }
+        });
+        this.setSortedTransactions(sortedTransactions);
+      } else {
+        let MSInADay = 864e5;
+        let sortingTimeInMS = Date.parse(value);
+        let endTimeOfSortingDateInMS = sortingTimeInMS - sortingTimeInMS % MSInADay + MSInADay - 1;
+        let startTimeOfSortingDateInMS = sortingTimeInMS - sortingTimeInMS % MSInADay;
+        this.props.transactions.forEach((element) => {
+          if (endTimeOfSortingDateInMS >= Date.parse(element.time) && Date.parse(element.time) >= startTimeOfSortingDateInMS) {
+            sortedTransactions.push(element);
+          }
+        });
+        this.setSortedTransactions(sortedTransactions);
+      }
+      toast.info(
+        /* @__PURE__ */ jsx(
+          Toast,
+          {
+            info: true,
+            title: this.props.intl.formatMessage(messages.sorted),
+            content: this.props.intl.formatMessage(
+              messages.transactionsHaveBeenSorted
+            )
+          }
+        )
+      );
+    } else {
+      this.setState({ isEmptyInputForSorting: true });
+    }
+  }
+  /**
+   * On Undo
+   * @method onUndo
+   * @returns {undefined}
+   */
+  onUndo() {
+    let transactionsSelected = false;
+    let undoTransactionsIds = map(
+      this.props.transactions.slice(0, this.props.transactions.length),
+      (transaction) => {
+        if (document.getElementById(transaction.id) !== null && document.getElementById(transaction.id).firstElementChild.firstElementChild.firstElementChild.checked) {
+          transactionsSelected = true;
+          return transaction.id;
+        }
+        return "";
+      }
+    );
+    if (transactionsSelected) {
+      this.setState({
+        isClickedOnUndoButton: true
+      });
+      this.props.revertTransactions(undoTransactionsIds);
+    } else {
+      toast.error(
+        /* @__PURE__ */ jsx(
+          Toast,
+          {
+            error: true,
+            title: this.props.intl.formatMessage(messages.noTransactionsSelected),
+            content: this.props.intl.formatMessage(
+              messages.noTransactionsSelectedToDoUndo
+            )
+          }
+        )
+      );
+    }
+    Array.from(
+      document.getElementsByClassName("transactions-checkboxes")
+    ).forEach((element) => {
+      element.firstElementChild.checked = false;
+    });
+  }
+  /**
+   * On Prev
+   * @method onPrev
+   * @returns {undefined}
+   */
+  onPrev() {
+    0 < this.state.lowerIndex && this.setState({
+      upperIndex: this.state.lowerIndex,
+      lowerIndex: this.state.lowerIndex - this.state.defaultTransactionsLenInTable
+    });
+  }
+  /**
+   * On Next
+   * @method onNext
+   * @returns {undefined}
+   */
+  onNext() {
+    this.props.transactions.length > this.state.upperIndex && this.setState({
+      lowerIndex: this.state.upperIndex,
+      upperIndex: this.state.upperIndex + this.state.defaultTransactionsLenInTable
+    });
+  }
+  /**
+   * Handle next and prev buttons visibility when transactions are sorted
+   * @method handleSortedNextPrevButtons
+   * @returns {undefined}
+   */
+  handleSortedNextPrevButtons() {
+    this.state.upperIndex >= this.state.sortedTransactions.length && this.state.showNextButton && this.setState({ showNextButton: false });
+    this.state.upperIndex < this.state.sortedTransactions.length && !this.state.showNextButton && this.setState({ showNextButton: true });
+    this.state.lowerIndex <= 0 && this.state.showPrevButton && this.setState({ showPrevButton: false });
+    this.state.lowerIndex > 0 && !this.state.showPrevButton && this.setState({ showPrevButton: true });
+  }
+  /**
+   * Handle next and prev buttons visibility when transactions are not sorted
+   * @method handleNotSortedNextPrevButtons
+   * @returns {undefined}
+   */
+  handleNotSortedNextPrevButtons() {
+    var _a, _b;
+    this.state.upperIndex >= ((_a = this.props.transactions) == null ? void 0 : _a.length) && this.state.showNextButton && this.setState({ showNextButton: false });
+    this.state.upperIndex < ((_b = this.props.transactions) == null ? void 0 : _b.length) && !this.state.showNextButton && this.setState({ showNextButton: true });
+    this.state.lowerIndex <= 0 && this.state.showPrevButton && this.setState({ showPrevButton: false });
+    this.state.lowerIndex > 0 && !this.state.showPrevButton && this.setState({ showPrevButton: true });
+  }
+  /**
+   * Handle next, prev buttons and table visibility
+   * @method handleTableVisiblity
+   * @returns {undefined}
+   */
+  handleTableVisiblity() {
+    var _a, _b;
+    if (this.state.sortedTransactions.length > 0) {
+      this.handleSortedNextPrevButtons();
+    } else if (!this.state.isSortingTypeSelected) {
+      ((_a = this.props.transactions) == null ? void 0 : _a.length) > 0 && this.state.isTransactionsNotFound && this.setState({ isTransactionsNotFound: false });
+      ((_b = this.props.transactions) == null ? void 0 : _b.length) <= 0 && !this.state.isTransactionsNotFound && this.setState({ isTransactionsNotFound: true });
+      this.handleNotSortedNextPrevButtons();
+    } else {
+      this.handleNotSortedNextPrevButtons();
+    }
+  }
+  /**
+   * Check transactions undone status
+   * @method checkTransactionsUndoneStatus
+   * @returns {undefined}
+   */
+  checkTransactionsUndoneStatus() {
+    if (this.props.revertRequest.error && this.props.revertRequest.error !== null && this.state.isClickedOnUndoButton) {
+      this.setState({
+        isClickedOnUndoButton: false
+      });
+      toast.error(
+        /* @__PURE__ */ jsx(
+          Toast,
+          {
+            error: true,
+            title: this.props.intl.formatMessage(messages.error),
+            content: this.props.intl.formatMessage(
+              messages.failedToUndoTransactions
+            )
+          }
+        )
+      );
+    } else if (this.props.revertRequest.error === null && this.state.isClickedOnUndoButton) {
+      this.setState({
+        isClickedOnUndoButton: false
+      });
+      toast.success(
+        /* @__PURE__ */ jsx(
+          Toast,
+          {
+            success: true,
+            title: this.props.intl.formatMessage(messages.success),
+            content: this.props.intl.formatMessage(
+              messages.successfullyUndoneTransactions
+            )
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Render method.
+   * @method render
+   * @returns {string} Markup for the component.
+   */
+  render() {
+    var _a, _b;
+    const transactionsRange = this.state.sortedTransactions.length > 0 && this.state.sortedTransactions.slice(
+      this.state.lowerIndex,
+      this.state.upperIndex
+    ) || ((_a = this.props.transactions) == null ? void 0 : _a.slice(
+      this.state.lowerIndex,
+      this.state.upperIndex
+    ));
+    this.handleTableVisiblity();
+    this.checkTransactionsUndoneStatus();
+    return /* @__PURE__ */ jsxs(Container, { id: "page-undo", className: "controlpanel-undo", children: [
+      /* @__PURE__ */ jsx(HelmetExport, { title: "Undo" }),
+      /* @__PURE__ */ jsxs(Segment.Group, { raised: true, children: [
+        /* @__PURE__ */ jsx(Segment, { className: "primary", children: /* @__PURE__ */ jsx(
+          FormattedMessage,
+          {
+            id: "Undo Controlpanel",
+            defaultMessage: "Undo Controlpanel"
+          }
+        ) }),
+        /* @__PURE__ */ jsx(Segment, { children: ((_b = this.props.transactions) == null ? void 0 : _b.length) > 0 && /* @__PURE__ */ jsx(
+          Form,
+          {
+            schema: {
+              fieldsets: [
+                {
+                  id: "default",
+                  title: this.props.intl.formatMessage(messages.default),
+                  fields: this.state.isSortingTypeSelected ? [
+                    "sortingTypes",
+                    this.state.sortType.toLowerCase() === "user name" && "sortByUsername" || this.state.sortType.toLowerCase() === "path" && "sortByPath" || this.state.sortType.toLowerCase() === "date" && "sortByDate"
+                  ] : ["sortingTypes"]
+                }
+              ],
+              properties: {
+                sortingTypes: {
+                  title: this.props.intl.formatMessage(messages.sortBy),
+                  description: this.props.intl.formatMessage(
+                    messages.sortByDescription
+                  ),
+                  type: "string",
+                  choices: map(["User Name", "Path", "Date"], (type) => [
+                    type,
+                    type
+                  ])
+                },
+                sortByUsername: {
+                  title: `Enter Username`,
+                  type: "string"
+                },
+                sortByPath: {
+                  title: `Enter Path`,
+                  type: "string"
+                },
+                sortByDate: {
+                  title: `Enter Date and Time`,
+                  type: "date"
+                }
+              },
+              required: []
+            },
+            error: this.state.isEmptyInputForSorting ? { message: "Please enter any input to perform sorting" } : void 0,
+            onChangeFormData: this.onSelect,
+            onSubmit: this.state.isSortingTypeSelected ? this.onSort : void 0,
+            onCancel: this.state.isSortingTypeSelected ? this.onCancel : void 0,
+            resetOnCancel: true
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(Segment.Group, { raised: true, children: [
+          /* @__PURE__ */ jsx(Segment, { className: "primary", children: /* @__PURE__ */ jsx(
+            FormattedMessage,
+            {
+              id: "Transactions",
+              defaultMessage: "Transactions"
+            }
+          ) }),
+          this.state.isTransactionsNotFound ? /* @__PURE__ */ jsx(Segment, { children: /* @__PURE__ */ jsx(
+            FormattedMessage,
+            {
+              id: "No Transactions Found",
+              defaultMessage: "No transactions found"
+            }
+          ) }) : /* @__PURE__ */ jsxs(Table, { selectable: true, fixed: true, celled: true, compact: true, singleLine: true, attached: true, children: [
+            /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+              /* @__PURE__ */ jsx(Table.HeaderCell, { width: 1, children: /* @__PURE__ */ jsx(
+                FormattedMessage,
+                {
+                  id: "Transactions Checkbox",
+                  defaultMessage: "#"
+                }
+              ) }),
+              /* @__PURE__ */ jsx(Table.HeaderCell, { width: 3, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "What", defaultMessage: "What" }) }),
+              /* @__PURE__ */ jsx(Table.HeaderCell, { width: 3, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "Who", defaultMessage: "Who" }) }),
+              /* @__PURE__ */ jsx(Table.HeaderCell, { width: 3, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "When", defaultMessage: "When" }) }),
+              /* @__PURE__ */ jsx(Table.HeaderCell, { width: 3, children: /* @__PURE__ */ jsx(FormattedMessage, { id: "Note", defaultMessage: "Note" }) }),
+              /* @__PURE__ */ jsx(Table.HeaderCell, {})
+            ] }) }),
+            /* @__PURE__ */ jsx(Table.Body, { children: map(transactionsRange, (transaction) => /* @__PURE__ */ jsxs(Table.Row, { id: transaction.id, children: [
+              /* @__PURE__ */ jsx(Table.Cell, { width: 1, children: /* @__PURE__ */ jsx(
+                Input,
+                {
+                  type: "checkbox",
+                  className: "transactions-checkboxes"
+                }
+              ) }),
+              /* @__PURE__ */ jsx(
+                Table.Cell,
+                {
+                  width: 3,
+                  title: [transaction.description].join(" "),
+                  children: transaction.description
+                }
+              ),
+              /* @__PURE__ */ jsx(Table.Cell, { width: 3, children: transaction.username ? transaction.username : "Zope" }),
+              /* @__PURE__ */ jsx(Table.Cell, { width: 3, children: transaction.time }),
+              /* @__PURE__ */ jsx(Table.Cell, { width: 3, children: transaction.description.includes("Undo") ? "Undone" : "" })
+            ] }, transaction.id)) }),
+            /* @__PURE__ */ jsx(Table.Footer, { children: /* @__PURE__ */ jsx(Table.Row, { children: /* @__PURE__ */ jsx(Table.HeaderCell, { textAlign: "center", colSpan: "6", children: /* @__PURE__ */ jsxs(Menu, { pagination: true, children: [
+              /* @__PURE__ */ jsx(Menu.Item, { as: "a", id: "prev-button", icon: true, children: this.state.showPrevButton ? /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  onClick: this.onPrev,
+                  name: paginationLeftSVG,
+                  title: "Prev"
+                }
+              ) : /* @__PURE__ */ jsx("div", { style: { width: "36px" } }) }),
+              /* @__PURE__ */ jsx(Menu.Item, { as: "a", icon: true, children: /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  name: undoSVG,
+                  id: "undo-button",
+                  className: "circled",
+                  size: "30px",
+                  title: this.props.intl.formatMessage(messages.undo),
+                  onClick: this.onUndo
+                }
+              ) }),
+              /* @__PURE__ */ jsx(Menu.Item, { as: "a", id: "next-button", icon: true, children: this.state.showNextButton ? /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  onClick: this.onNext,
+                  name: paginationRightSVG,
+                  title: "Next"
+                }
+              ) : /* @__PURE__ */ jsx("div", { style: { width: "36px" } }) })
+            ] }) }) }) })
+          ] })
+        ] })
+      ] }),
+      this.state.isClient && createPortal(
+        /* @__PURE__ */ jsx(
+          Toolbar,
+          {
+            pathname: this.props.pathname,
+            hideDefaultViewButtons: true,
+            inner: /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(Link, { to: "/controlpanel", className: "item", children: /* @__PURE__ */ jsx(
+              Icon,
+              {
+                name: backSVG,
+                "aria-label": this.props.intl.formatMessage(messages.back),
+                className: "contents circled",
+                size: "30px",
+                title: this.props.intl.formatMessage(messages.back)
+              }
+            ) }) })
+          }
+        ),
+        document.getElementById("toolbar")
+      )
+    ] });
+  }
+}
+/**
+ * Property types.
+ * @property {Object} propTypes Property types.
+ * @static
+ */
+__publicField(UndoControlpanel, "propTypes", {
+  getTransactions: PropTypes.func.isRequired,
+  revertTransactions: PropTypes.func.isRequired,
+  transactions: PropTypes.arrayOf(
+    PropTypes.shape({
+      description: PropTypes.string,
+      id: PropTypes.string,
+      size: PropTypes.number,
+      time: PropTypes.string,
+      username: PropTypes.string
+    })
+  ),
+  revertRequest: PropTypes.shape({
+    loaded: PropTypes.bool,
+    loading: PropTypes.bool
+  }).isRequired
+});
+const UndoControlpanel$1 = compose(
+  injectIntl,
+  connect(
+    (state, props) => ({
+      pathname: props.location.pathname,
+      transactions: state.transactions.transactions_recieved,
+      revertRequest: state.transactions.revert
+    }),
+    { getTransactions, revertTransactions }
+  )
+)(UndoControlpanel);
+export {
+  UndoControlpanel$1 as default
+};