muffin-admin 1.30.0 → 1.31.2

package/Makefile

@@ -3,6 +3,13 @@ all: node_modules
 
 node_modules: package.json
 	npm install
+	touch node_modules
+
+npm: node_modules
+	$(CURDIR)/node_modules/.bin/babel src --out-dir dist
+
+pypi:
+	$(CURDIR)/node_modules/.bin/webpack
 
 watch: node_modules
 	$(CURDIR)/node_modules/.bin/webpack --watch

package/dist/admin.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactAdmin = require("react-admin");
+
+var _material = require("@mui/material");
+
+var icons = _interopRequireWildcard(require("@mui/icons-material"));
+
+var _authprovider = _interopRequireDefault(require("./authprovider"));
+
+var _dataprovider = _interopRequireDefault(require("./dataprovider"));
+
+var _utils = require("./utils");
+
+require("./dashboard");
+
+require("./resources");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// Initialize the admin
+(0, _utils.setupAdmin)('admin', function (props) {
+  var apiUrl = props.apiUrl,
+      auth = props.auth,
+      adminProps = props.adminProps,
+      appBarLinks = props.appBarLinks,
+      dashboard = props.dashboard,
+      resources = props.resources;
+
+  var appBar = function appBar(props) {
+    return /*#__PURE__*/_react["default"].createElement(_reactAdmin.AppBar, props, /*#__PURE__*/_react["default"].createElement(_material.Typography, {
+      variant: "h6",
+      color: "inherit",
+      id: "react-admin-title",
+      style: {
+        flex: 1,
+        textOverflow: 'ellipsis',
+        whiteSpace: 'nowrap',
+        overflow: 'hidden'
+      }
+    }), appBarLinks.map(function (info) {
+      return /*#__PURE__*/_react["default"].createElement(_material.Tooltip, {
+        key: info.url,
+        title: info.title
+      }, /*#__PURE__*/_react["default"].createElement(_material.IconButton, {
+        color: "inherit",
+        href: info.url
+      }, /*#__PURE__*/_react["default"].createElement(_material.SvgIcon, {
+        component: icons[info.icon]
+      })));
+    }));
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(_reactAdmin.Admin, (0, _extends2["default"])({
+    authProvider: (0, _utils.processAdmin)('auth', auth),
+    dataProvider: (0, _utils.processAdmin)('data', apiUrl),
+    dashboard: (0, _utils.processAdmin)('dashboard', dashboard),
+    loginPage: (0, _utils.processAdmin)('login', auth),
+    layout: function layout(props) {
+      return /*#__PURE__*/_react["default"].createElement(_reactAdmin.Layout, (0, _extends2["default"])({
+        appBar: appBar
+      }, props));
+    }
+  }, adminProps), (0, _utils.processAdmin)('resources', resources));
+}); // Initialize authentication and data providers
+
+(0, _utils.setupAdmin)('auth', _authprovider["default"]);
+(0, _utils.setupAdmin)('data', _dataprovider["default"]); // Initialize login page
+
+(0, _utils.setupAdmin)('login', function () {
+  return _reactAdmin.Login;
+});

package/dist/authprovider.js

@@ -0,0 +1,250 @@
+"use strict";
+
+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 _jsCookie = _interopRequireDefault(require("js-cookie"));
+
+var _utils = require("./utils");
+
+(0, _utils.setupAdmin)('auth-get', function (_ref) {
+  var storage = _ref.storage;
+  return function (name) {
+    return storage == 'localstorage' ? localStorage.getItem(name) : _jsCookie["default"].get(name);
+  };
+});
+(0, _utils.setupAdmin)('auth-set', function (_ref2) {
+  var storage = _ref2.storage;
+  return function (name, value) {
+    if (storage == 'localstorage') {
+      localStorage.setItem(name, value);
+      _utils.requestHeaders['Authorization'] = value;
+    } else _jsCookie["default"].set(name, value);
+  };
+});
+
+var _default = function _default(props) {
+  var identityURL = props.identityURL,
+      authorizeURL = props.authorizeURL,
+      logoutURL = props.logoutURL,
+      required = props.required,
+      storage_name = props.storage_name;
+  var authGet = (0, _utils.processAdmin)('auth-get', props);
+  var authSet = (0, _utils.processAdmin)('auth-set', props); // Initialize request headers
+
+  authSet(storage_name, authGet(storage_name));
+
+  var getIdentity = /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var _yield$makeRequest, json;
+
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!identityURL) {
+                _context.next = 6;
+                break;
+              }
+
+              _context.next = 3;
+              return (0, _utils.makeRequest)(identityURL);
+
+            case 3:
+              _yield$makeRequest = _context.sent;
+              json = _yield$makeRequest.json;
+              return _context.abrupt("return", json);
+
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function getIdentity() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  if (required) return {
+    login: function () {
+      var _login = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(data) {
+        var _yield$makeRequest2, json;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (authorizeURL) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                throw {
+                  message: 'Authorization is not supported'
+                };
+
+              case 2:
+                _context2.next = 4;
+                return (0, _utils.makeRequest)(authorizeURL, {
+                  data: data,
+                  method: 'POST'
+                });
+
+              case 4:
+                _yield$makeRequest2 = _context2.sent;
+                json = _yield$makeRequest2.json;
+                authSet(storage_name, json);
+
+              case 7:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function login(_x) {
+        return _login.apply(this, arguments);
+      }
+
+      return login;
+    }(),
+    checkError: function () {
+      var _checkError = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(error) {
+        var status;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                status = error.status;
+
+                if (!(status == 401 || status == 403)) {
+                  _context3.next = 4;
+                  break;
+                }
+
+                // Clean storage
+                authSet(storage_name, '');
+                throw {
+                  message: 'Invalid authorization',
+                  redirectTo: logoutURL,
+                  logoutUser: !logoutURL
+                };
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      function checkError(_x2) {
+        return _checkError.apply(this, arguments);
+      }
+
+      return checkError;
+    }(),
+    checkAuth: function () {
+      var _checkAuth = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(data) {
+        var auth, user;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                auth = authGet(storage_name);
+
+                if (auth) {
+                  _context4.next = 3;
+                  break;
+                }
+
+                throw {
+                  message: 'Authorization required'
+                };
+
+              case 3:
+                if (identityURL) {
+                  _context4.next = 5;
+                  break;
+                }
+
+                return _context4.abrupt("return", auth);
+
+              case 5:
+                _context4.next = 7;
+                return getIdentity();
+
+              case 7:
+                user = _context4.sent;
+
+                if (user) {
+                  _context4.next = 10;
+                  break;
+                }
+
+                throw {
+                  message: 'Authorization required'
+                };
+
+              case 10:
+                return _context4.abrupt("return", user);
+
+              case 11:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      function checkAuth(_x3) {
+        return _checkAuth.apply(this, arguments);
+      }
+
+      return checkAuth;
+    }(),
+    logout: function () {
+      var _logout = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                // Clean storage
+                authSet(storage_name, '');
+                if (logoutURL) window.location = logoutURL;
+
+              case 2:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }));
+
+      function logout() {
+        return _logout.apply(this, arguments);
+      }
+
+      return logout;
+    }(),
+    getIdentity: getIdentity,
+    getPermissions: function getPermissions(data) {
+      var role = authGet(storage_name + '_role');
+      return role ? Promise.resolve(role) : Promise.reject();
+    }
+  };
+};
+
+exports["default"] = _default;

package/dist/buttons/ActionButton.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.BulkActionButton = exports.ActionButton = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactAdmin = require("react-admin");
+
+var icons = _interopRequireWildcard(require("@mui/icons-material"));
+
+var _useAction = _interopRequireDefault(require("../hooks/useAction"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var BulkActionButton = function BulkActionButton(_ref) {
+  var label = _ref.label,
+      icon = _ref.icon,
+      title = _ref.title,
+      action = _ref.action,
+      resource = _ref.resource,
+      selectedIds = _ref.selectedIds;
+  var refresh = (0, _reactAdmin.useRefresh)(),
+      unselectAll = (0, _reactAdmin.useUnselectAll)(resource),
+      notify = (0, _reactAdmin.useNotify)(),
+      Icon = icons[icon];
+  var mutation = (0, _useAction["default"])(resource, action);
+
+  var onClick = function onClick() {
+    mutation.mutate({
+      action: action,
+      ids: selectedIds
+    }, {
+      onSuccess: function onSuccess(_ref2) {
+        var data = _ref2.data;
+        if (data && data.message) notify(data.message, {
+          type: 'success'
+        });
+        refresh();
+        unselectAll();
+      },
+      onError: function onError(err) {
+        notify(typeof err === 'string' ? err : err.message, {
+          type: 'error'
+        });
+      }
+    });
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(_reactAdmin.Button, {
+    label: label,
+    title: title,
+    onClick: onClick,
+    disabled: mutation.isLoading
+  }, Icon && /*#__PURE__*/_react["default"].createElement(Icon, null));
+};
+
+exports.BulkActionButton = BulkActionButton;
+
+var ActionButton = function ActionButton(props) {
+  var icon = props.icon,
+      label = props.label,
+      title = props.title,
+      resource = props.resource,
+      action = props.action;
+  var record = (0, _reactAdmin.useRecordContext)();
+  var mutation = (0, _useAction["default"])(resource, action);
+  var refresh = (0, _reactAdmin.useRefresh)(),
+      notify = (0, _reactAdmin.useNotify)(),
+      Icon = icons[icon];
+
+  var onClick = function onClick() {
+    mutation.mutate({
+      record: record
+    }, {
+      onSuccess: function onSuccess(_ref3) {
+        var data = _ref3.data;
+        refresh();
+        if (data && data.redirectTo) window.location = data.redirectTo;
+        if (data && data.message) notify(data.message, {
+          type: 'success'
+        });
+      },
+      onError: function onError(error) {
+        notify(typeof error === 'string' ? error : error.message, {
+          type: 'error'
+        });
+      }
+    });
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(_reactAdmin.Button, {
+    label: label,
+    title: title,
+    onClick: onClick,
+    disabled: mutation.isLoading
+  }, Icon && /*#__PURE__*/_react["default"].createElement(Icon, null));
+};
+
+exports.ActionButton = ActionButton;
+var _default = ActionButton;
+exports["default"] = _default;

package/dist/buttons/LinkButton.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactAdmin = require("react-admin");
+
+var _reactRouterDom = require("react-router-dom");
+
+var icons = _interopRequireWildcard(require("@mui/icons-material"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var LinkButton = function LinkButton(_ref) {
+  var label = _ref.label,
+      icon = _ref.icon,
+      title = _ref.title,
+      resource = _ref.resource,
+      filters = _ref.filters;
+  var Icon = icons[icon] || icon;
+  var linkParams = {
+    pathname: "/".concat(resource),
+    search: filters ? "filter=".concat(JSON.stringify(filters)) : undefined
+  };
+  return /*#__PURE__*/_react["default"].createElement(_reactAdmin.Button, {
+    label: label,
+    title: title,
+    component: _reactRouterDom.Link,
+    to: linkParams
+  }, Icon && /*#__PURE__*/_react["default"].createElement(Icon, null));
+};
+
+var _default = LinkButton;
+exports["default"] = _default;

package/dist/dashboard.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _material = require("@mui/material");
+
+var _utils = require("./utils");
+
+// import ReactJSON from "react-json-view";
+var AdminTableView = function AdminTableView(_ref) {
+  var src = _ref.src;
+  return /*#__PURE__*/_react["default"].createElement(_material.Table, null, /*#__PURE__*/_react["default"].createElement(_material.TableBody, null, src.map(function (row, idx) {
+    return /*#__PURE__*/_react["default"].createElement(_material.TableRow, {
+      key: idx,
+      hover: true
+    }, row.map(function (cell, idx) {
+      return /*#__PURE__*/_react["default"].createElement(_material.TableCell, {
+        key: idx
+      }, cell);
+    }));
+  })));
+};
+
+var AdminCard = function AdminCard(_ref2) {
+  var src = _ref2.src;
+
+  if (Array.isArray(src)) {
+    return /*#__PURE__*/_react["default"].createElement(_material.Grid, {
+      container: true,
+      item: true,
+      spacing: 2
+    }, src.map(function (card, idx) {
+      return /*#__PURE__*/_react["default"].createElement(AdminCard, {
+        key: idx,
+        src: card
+      });
+    }));
+  }
+
+  var title = src.title,
+      value = src.value;
+  return /*#__PURE__*/_react["default"].createElement(_material.Grid, {
+    item: true,
+    xs: true
+  }, /*#__PURE__*/_react["default"].createElement(_material.Card, null, /*#__PURE__*/_react["default"].createElement(_material.CardContent, null, /*#__PURE__*/_react["default"].createElement(_material.Typography, {
+    variant: "h5",
+    component: "h2",
+    m: 2,
+    style: {
+      textAlign: 'center'
+    }
+  }, title), Array.isArray(value) && /*#__PURE__*/_react["default"].createElement(AdminTableView, {
+    src: value
+  }) || /*#__PURE__*/_react["default"].createElement("pre", null, JSON.stringify(value, null, 2)))));
+}; // Process dashboard
+
+
+(0, _utils.setupAdmin)('dashboard', function (props) {
+  if (!props) return;
+  return function () {
+    return /*#__PURE__*/_react["default"].createElement(_material.Grid, {
+      container: true,
+      spacing: 1
+    }, /*#__PURE__*/_react["default"].createElement(AdminCard, {
+      src: props
+    }));
+  };
+});