@akemona-org/strapi-admin 3.7.0

package/admin/src/containers/Admin/Logout/index.js

@@ -0,0 +1,60 @@
+/**
+ *
+ * Logout
+ *
+ */
+
+/* eslint-disable */
+import React, { useState } from 'react';
+import { FormattedMessage } from 'react-intl';
+import { withRouter } from 'react-router-dom';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { ButtonDropdown, DropdownItem, DropdownMenu, DropdownToggle } from 'reactstrap';
+import { get } from 'lodash';
+import { auth } from 'strapi-helper-plugin';
+import Wrapper from './components';
+
+const Logout = ({ history: { push } }) => {
+  const [isOpen, setIsOpen] = useState(false);
+
+  const handleGoToMe = () => {
+    push({
+      pathname: `/me`,
+    });
+  };
+
+  const handleLogout = () => {
+    auth.clearAppStorage();
+    push('/auth/login');
+  };
+
+  const toggle = () => setIsOpen(prev => !prev);
+
+  const userInfo = auth.getUserInfo();
+  const displayName =
+    userInfo && userInfo.firstname && userInfo.lastname
+      ? `${userInfo.firstname} ${userInfo.lastname}`
+      : get(userInfo, 'username', '');
+
+  return (
+    <Wrapper>
+      <ButtonDropdown isOpen={isOpen} toggle={toggle}>
+        <DropdownToggle>
+          {displayName}
+          <FontAwesomeIcon icon="caret-down" />
+        </DropdownToggle>
+        <DropdownMenu className="dropDownContent">
+          <DropdownItem onClick={handleGoToMe} className="item">
+            <FormattedMessage id="app.components.Logout.profile" />
+          </DropdownItem>
+          <DropdownItem onClick={handleLogout}>
+            <FormattedMessage id="app.components.Logout.logout" />
+            <FontAwesomeIcon icon="sign-out-alt" />
+          </DropdownItem>
+        </DropdownMenu>
+      </ButtonDropdown>
+    </Wrapper>
+  );
+};
+
+export default withRouter(Logout);

package/admin/src/containers/Admin/Wrapper.js

@@ -0,0 +1,27 @@
+import styled from 'styled-components';
+
+const Wrapper = styled.div`
+  display: flex;
+  overflow-x: hidden;
+
+  p,
+  span {
+    font-family: Lato;
+  }
+
+  .adminPageRightWrapper {
+    width: ${props => `calc(100% - ${props.theme.main.sizes.leftMenu.width})`};
+  }
+`;
+
+Wrapper.defaultProps = {
+  theme: {
+    main: {
+      sizes: {
+        leftMenu: {},
+      },
+    },
+  },
+};
+
+export default Wrapper;

package/admin/src/containers/Admin/actions.js

@@ -0,0 +1,21 @@
+/*
+ *
+ * Admin actions
+ *
+ */
+
+import { GET_STRAPI_LATEST_RELEASE_SUCCEEDED, SET_APP_ERROR } from './constants';
+
+export function getStrapiLatestReleaseSucceeded(latestStrapiReleaseTag, shouldUpdateStrapi) {
+  return {
+    type: GET_STRAPI_LATEST_RELEASE_SUCCEEDED,
+    latestStrapiReleaseTag,
+    shouldUpdateStrapi,
+  };
+}
+
+export function setAppError() {
+  return {
+    type: SET_APP_ERROR,
+  };
+}

package/admin/src/containers/Admin/constants.js

@@ -0,0 +1,9 @@
+/*
+ *
+ * Admin constants
+ *
+ */
+
+export const SET_APP_ERROR = 'StrapiAdmin/Admin/SET_APP_ERROR';
+export const GET_STRAPI_LATEST_RELEASE_SUCCEEDED =
+  'StrapiAdmin/Admin/GET_STRAPI_LATEST_RELEASE_SUCCEEDED';

package/admin/src/containers/Admin/index.js

@@ -0,0 +1,364 @@
+/**
+ *
+ * Admin
+ *
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import axios from 'axios';
+import { connect } from 'react-redux';
+import { createStructuredSelector } from 'reselect';
+import { bindActionCreators, compose } from 'redux';
+import { Switch, Route } from 'react-router-dom';
+import { injectIntl } from 'react-intl';
+import { isEmpty } from 'lodash';
+// Components from strapi-helper-plugin
+import {
+  difference,
+  GlobalContextProvider,
+  LoadingIndicatorPage,
+  OverlayBlocker,
+  CheckPagePermissions,
+  request,
+} from 'strapi-helper-plugin';
+import { SETTINGS_BASE_URL, SHOW_TUTORIALS, STRAPI_UPDATE_NOTIF } from '../../config';
+import { checkLatestStrapiVersion } from '../../utils';
+
+import adminPermissions from '../../permissions';
+import Header from '../../components/Header/index';
+import NavTopRightWrapper from '../../components/NavTopRightWrapper';
+import LeftMenu from '../LeftMenu';
+import InstalledPluginsPage from '../InstalledPluginsPage';
+import HomePage from '../HomePage';
+import MarketplacePage from '../MarketplacePage';
+import NotFoundPage from '../NotFoundPage';
+import OnboardingVideos from '../Onboarding';
+import PermissionsManager from '../PermissionsManager';
+import PluginDispatcher from '../PluginDispatcher';
+import ProfilePage from '../ProfilePage';
+import SettingsPage from '../SettingsPage';
+import Logout from './Logout';
+import {
+  disableGlobalOverlayBlocker,
+  enableGlobalOverlayBlocker,
+  getInfosDataSucceeded,
+  updatePlugin,
+} from '../App/actions';
+import makeSelecApp from '../App/selectors';
+import { getStrapiLatestReleaseSucceeded, setAppError } from './actions';
+import makeSelectAdmin from './selectors';
+import Wrapper from './Wrapper';
+import Content from './Content';
+
+export class Admin extends React.Component {
+  // eslint-disable-line react/prefer-stateless-function
+
+  // This state is really temporary until we create a menu API
+  state = { updateMenu: null };
+
+  helpers = {
+    updatePlugin: this.props.updatePlugin,
+  };
+
+  componentDidMount() {
+    this.emitEvent('didAccessAuthenticatedAdministration');
+    this.initApp();
+  }
+
+  shouldComponentUpdate(prevProps, prevState) {
+    return !isEmpty(difference(prevProps, this.props)) || !isEmpty(prevState, this.state);
+  }
+
+  /* istanbul ignore next */
+  componentDidCatch(error, info) {
+    /* eslint-disable */
+    console.log('An error has occured');
+    console.log('--------------------');
+    console.log(error);
+    console.log('Here is some infos');
+    console.log(info);
+    /* eslint-enable */
+
+    // Display the error log component which is not designed yet
+    this.props.setAppError();
+  }
+
+  emitEvent = async (/* event, properties */) => {
+    const {
+      global: { uuid },
+    } = this.props;
+
+    if (uuid) {
+      try {
+        /*  await axios.post('https://analytics.strapi.io/track', {
+          event,
+          // PROJECT_TYPE is an env variable defined in the webpack config
+          // eslint-disable-next-line no-undef
+          properties: { ...properties, projectType: PROJECT_TYPE },
+          uuid,
+        }); */
+      } catch (err) {
+        // Silent
+      }
+    }
+  };
+
+  fetchAppInfo = async () => {
+    try {
+      const { data } = await request('/admin/information', { method: 'GET' });
+
+      this.props.getInfosDataSucceeded(data);
+    } catch (err) {
+      console.error(err);
+      strapi.notification.error('notification.error');
+    }
+  };
+
+  fetchStrapiLatestRelease = async () => {
+    const {
+      global: { strapiVersion },
+      getStrapiLatestReleaseSucceeded,
+    } = this.props;
+
+    if (!STRAPI_UPDATE_NOTIF) {
+      return;
+    }
+
+    try {
+      const {
+        data: { tag_name },
+      } = await axios.get('https://api.github.com/repos/strapi/strapi/releases/latest');
+      const shouldUpdateStrapi = checkLatestStrapiVersion(strapiVersion, tag_name);
+
+      getStrapiLatestReleaseSucceeded(tag_name, shouldUpdateStrapi);
+
+      const showUpdateNotif = !JSON.parse(localStorage.getItem('STRAPI_UPDATE_NOTIF'));
+
+      if (!showUpdateNotif) {
+        return;
+      }
+
+      if (shouldUpdateStrapi) {
+        strapi.notification.toggle({
+          type: 'info',
+          message: { id: 'notification.version.update.message' },
+          link: {
+            url: `https://github.com/strapi/strapi/releases/tag/${tag_name}`,
+            label: {
+              id: 'notification.version.update.link',
+            },
+          },
+          blockTransition: true,
+          onClose: () => localStorage.setItem('STRAPI_UPDATE_NOTIF', true),
+        });
+      }
+    } catch (err) {
+      // Silent
+    }
+  };
+
+  hasApluginNotReady = (props) => {
+    const {
+      global: { plugins },
+    } = props;
+
+    return !Object.keys(plugins).every((plugin) => plugins[plugin].isReady === true);
+  };
+
+  initApp = async () => {
+    await this.fetchAppInfo();
+    await this.fetchStrapiLatestRelease();
+  };
+
+  /**
+   * Display the app loader until the app is ready
+   * @returns {Boolean}
+   */
+  showLoader = () => {
+    return this.hasApluginNotReady(this.props);
+  };
+
+  renderInitializers = () => {
+    const {
+      global: { plugins },
+    } = this.props;
+
+    return Object.keys(plugins).reduce((acc, current) => {
+      const InitializerComponent = plugins[current].initializer;
+
+      if (InitializerComponent) {
+        const key = plugins[current].id;
+
+        acc.push(<InitializerComponent key={key} {...this.props} {...this.helpers} />);
+      }
+
+      return acc;
+    }, []);
+  };
+
+  renderPluginDispatcher = (props) => {
+    // NOTE: Send the needed props instead of everything...
+
+    return <PluginDispatcher {...this.props} {...props} {...this.helpers} />;
+  };
+
+  renderRoute = (props, Component) => <Component {...this.props} {...props} />;
+
+  setUpdateMenu = (updateMenuFn) => {
+    this.setState({ updateMenu: updateMenuFn });
+  };
+
+  render() {
+    const {
+      admin: { shouldUpdateStrapi },
+      global: {
+        autoReload,
+        blockApp,
+        currentEnvironment,
+        overlayBlockerData,
+        plugins,
+        showGlobalAppBlocker,
+        strapiVersion,
+      },
+      disableGlobalOverlayBlocker,
+      enableGlobalOverlayBlocker,
+      intl: { formatMessage, locale },
+      updatePlugin,
+    } = this.props;
+
+    // We need the admin data in order to make the initializers work
+    if (this.showLoader()) {
+      return (
+        <>
+          {this.renderInitializers()}
+          <LoadingIndicatorPage />
+        </>
+      );
+    }
+
+    return (
+      <PermissionsManager>
+        <GlobalContextProvider
+          autoReload={autoReload}
+          emitEvent={this.emitEvent}
+          currentEnvironment={currentEnvironment}
+          currentLocale={locale}
+          disableGlobalOverlayBlocker={disableGlobalOverlayBlocker}
+          enableGlobalOverlayBlocker={enableGlobalOverlayBlocker}
+          formatMessage={formatMessage}
+          shouldUpdateStrapi={shouldUpdateStrapi}
+          plugins={plugins}
+          settingsBaseURL={SETTINGS_BASE_URL || '/settings'}
+          strapiVersion={strapiVersion}
+          updatePlugin={updatePlugin}
+          updateMenu={this.state.updateMenu}
+        >
+          <Wrapper>
+            <LeftMenu
+              shouldUpdateStrapi={shouldUpdateStrapi}
+              version={strapiVersion}
+              plugins={plugins}
+              setUpdateMenu={this.setUpdateMenu}
+            />
+            <NavTopRightWrapper>
+              {/* Injection zone not ready yet */}
+              <Logout />
+            </NavTopRightWrapper>
+            <div className="adminPageRightWrapper">
+              <Header />
+              <Content>
+                <Switch>
+                  <Route path="/" render={(props) => this.renderRoute(props, HomePage)} exact />
+                  <Route path="/me" component={ProfilePage} />
+                  <Route path="/plugins/:pluginId" render={this.renderPluginDispatcher} />
+                  <Route path="/list-plugins" exact>
+                    <CheckPagePermissions permissions={adminPermissions.marketplace.main}>
+                      <InstalledPluginsPage />
+                    </CheckPagePermissions>
+                  </Route>
+                  <Route path="/marketplace">
+                    <CheckPagePermissions permissions={adminPermissions.marketplace.main}>
+                      <MarketplacePage />
+                    </CheckPagePermissions>
+                  </Route>
+                  <Route
+                    path={`${SETTINGS_BASE_URL || '/settings'}/:settingId`}
+                    component={SettingsPage}
+                  />
+                  <Route path={SETTINGS_BASE_URL || '/settings'} component={SettingsPage} exact />
+                  <Route key="7" path="" component={NotFoundPage} />
+                  <Route key="8" path="/404" component={NotFoundPage} />
+                </Switch>
+              </Content>
+            </div>
+            <OverlayBlocker
+              key="overlayBlocker"
+              isOpen={blockApp && showGlobalAppBlocker}
+              {...overlayBlockerData}
+            />
+            {SHOW_TUTORIALS && <OnboardingVideos />}
+          </Wrapper>
+        </GlobalContextProvider>
+      </PermissionsManager>
+    );
+  }
+}
+
+Admin.defaultProps = {
+  intl: {
+    formatMessage: () => {},
+    locale: 'en',
+  },
+};
+
+Admin.propTypes = {
+  admin: PropTypes.shape({
+    appError: PropTypes.bool,
+    shouldUpdateStrapi: PropTypes.bool.isRequired,
+  }).isRequired,
+  disableGlobalOverlayBlocker: PropTypes.func.isRequired,
+  enableGlobalOverlayBlocker: PropTypes.func.isRequired,
+  getInfosDataSucceeded: PropTypes.func.isRequired,
+  getStrapiLatestReleaseSucceeded: PropTypes.func.isRequired,
+  global: PropTypes.shape({
+    autoReload: PropTypes.bool,
+    blockApp: PropTypes.bool,
+    currentEnvironment: PropTypes.string,
+    overlayBlockerData: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
+    plugins: PropTypes.object,
+    showGlobalAppBlocker: PropTypes.bool,
+    strapiVersion: PropTypes.string,
+    uuid: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
+  }).isRequired,
+  intl: PropTypes.shape({
+    formatMessage: PropTypes.func,
+    locale: PropTypes.string,
+  }),
+  location: PropTypes.object.isRequired,
+  setAppError: PropTypes.func.isRequired,
+  updatePlugin: PropTypes.func.isRequired,
+};
+
+const mapStateToProps = createStructuredSelector({
+  admin: makeSelectAdmin(),
+  global: makeSelecApp(),
+});
+
+export function mapDispatchToProps(dispatch) {
+  return bindActionCreators(
+    {
+      disableGlobalOverlayBlocker,
+      enableGlobalOverlayBlocker,
+      getInfosDataSucceeded,
+      getStrapiLatestReleaseSucceeded,
+      setAppError,
+      updatePlugin,
+    },
+    dispatch
+  );
+}
+
+const withConnect = connect(mapStateToProps, mapDispatchToProps);
+
+export default compose(injectIntl, withConnect)(Admin);

package/admin/src/containers/Admin/reducer.js

@@ -0,0 +1,39 @@
+/*
+ *
+ * Admin reducer
+ *
+ */
+
+import produce from 'immer';
+import packageJSON from '../../../../package.json';
+
+import { GET_STRAPI_LATEST_RELEASE_SUCCEEDED, SET_APP_ERROR } from './constants';
+
+const packageVersion = packageJSON.version;
+const initialState = {
+  appError: false,
+  latestStrapiReleaseTag: `v${packageVersion}`,
+  shouldUpdateStrapi: false,
+};
+
+const reducer = (state = initialState, action) =>
+  // eslint-disable-next-line consistent-return
+  produce(state, draftState => {
+    switch (action.type) {
+      case GET_STRAPI_LATEST_RELEASE_SUCCEEDED: {
+        draftState.latestStrapiReleaseTag = action.latestStrapiReleaseTag;
+        draftState.shouldUpdateStrapi = action.shouldUpdateStrapi;
+        break;
+      }
+
+      case SET_APP_ERROR: {
+        draftState.appError = true;
+        break;
+      }
+      default:
+        return state;
+    }
+  });
+
+export default reducer;
+export { initialState };

package/admin/src/containers/Admin/selectors.js

@@ -0,0 +1,22 @@
+import { createSelector } from 'reselect';
+import { initialState } from './reducer';
+
+/**
+ * Direct selector to the admin state domain
+ */
+const selectAdminDomain = () => state => {
+  return state.get('admin') || initialState;
+};
+
+/**
+ * Other specific selectors
+ */
+
+/**
+ * Default selector used by Admin
+ */
+
+const makeSelectAdmin = () => createSelector(selectAdminDomain(), substate => substate);
+
+export default makeSelectAdmin;
+export { selectAdminDomain };

package/admin/src/containers/App/actions.js

@@ -0,0 +1,87 @@
+/*
+ *
+ * LanguageProvider actions
+ *
+ */
+
+import {
+  DISABLE_GLOBAL_OVERLAY_BLOCKER,
+  ENABLE_GLOBAL_OVERLAY_BLOCKER,
+  FREEZE_APP,
+  GET_INFOS_DATA_SUCCEEDED,
+  GET_DATA_SUCCEEDED,
+  LOAD_PLUGIN,
+  PLUGIN_DELETED,
+  PLUGIN_LOADED,
+  UNFREEZE_APP,
+  UPDATE_PLUGIN,
+} from './constants';
+
+export function disableGlobalOverlayBlocker() {
+  return {
+    type: DISABLE_GLOBAL_OVERLAY_BLOCKER,
+  };
+}
+
+export function enableGlobalOverlayBlocker() {
+  return {
+    type: ENABLE_GLOBAL_OVERLAY_BLOCKER,
+  };
+}
+
+export function freezeApp(data) {
+  return {
+    type: FREEZE_APP,
+    data,
+  };
+}
+
+export function getInfosDataSucceeded(data) {
+  return {
+    type: GET_INFOS_DATA_SUCCEEDED,
+    data,
+  };
+}
+
+export function getDataSucceeded(data) {
+  return {
+    type: GET_DATA_SUCCEEDED,
+    data,
+  };
+}
+
+export function loadPlugin(newPlugin) {
+  return {
+    type: LOAD_PLUGIN,
+    plugin: newPlugin,
+  };
+}
+
+export function pluginDeleted(plugin) {
+  return {
+    type: PLUGIN_DELETED,
+    plugin,
+  };
+}
+
+export function pluginLoaded(newPlugin) {
+  return {
+    type: PLUGIN_LOADED,
+    plugin: newPlugin,
+  };
+}
+
+export function unfreezeApp() {
+  return {
+    type: UNFREEZE_APP,
+  };
+}
+
+export function updatePlugin(pluginId, updatedKey, updatedValue) {
+  return {
+    type: UPDATE_PLUGIN,
+    pluginId,
+    updatedKey,
+    updatedValue,
+  };
+}

package/admin/src/containers/App/components.js

@@ -0,0 +1,15 @@
+import styled from 'styled-components';
+
+const Wrapper = styled.div`
+  font-family: 'Lato';
+  font-size: 1.4rem;
+  font-weight: 400;
+  line-height: 1.5;
+  color: #292b2c;
+`;
+
+const Content = styled.div`
+  display: block;
+`;
+
+export { Content, Wrapper };

package/admin/src/containers/App/constants.js

@@ -0,0 +1,18 @@
+/*
+ *
+ * App constants
+ *
+ */
+
+export const FREEZE_APP = 'app/App/FREEZE_APP';
+export const LOAD_PLUGIN = 'app/App/LOAD_PLUGIN';
+export const PLUGIN_LOADED = 'app/App/PLUGIN_LOADED';
+export const PLUGIN_DELETED = 'app/App/PLUGIN_DELETED';
+export const UNFREEZE_APP = 'app/App/UNFREEZE_APP';
+
+export const UPDATE_PLUGIN = 'app/App/UPDATE_PLUGIN';
+export const DISABLE_GLOBAL_OVERLAY_BLOCKER =
+  'app/App/OverlayBlocker/DISABLE_GLOBAL_OVERLAY_BLOCKER';
+export const ENABLE_GLOBAL_OVERLAY_BLOCKER = 'app/App/OverlayBlocker/ENABLE_GLOBAL_OVERLAY_BLOCKER';
+export const GET_DATA_SUCCEEDED = 'app/App/GET_DATA_SUCCEEDED';
+export const GET_INFOS_DATA_SUCCEEDED = 'admin/App/GET_INFOS_DATA_SUCCEEDED';