@akemona-org/strapi-plugin-documentation 3.7.0

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

@@ -0,0 +1,283 @@
+/*
+ *
+ * HomePage
+ *
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import { connect } from 'react-redux';
+import { CopyToClipboard } from 'react-copy-to-clipboard';
+import { bindActionCreators, compose } from 'redux';
+import { get, isEmpty } from 'lodash';
+import { Header } from '@buffetjs/custom';
+import { Button } from '@buffetjs/core';
+import {
+  auth,
+  PopUpWarning,
+  LoadingIndicatorPage,
+  InputsIndex as Input,
+  GlobalContext,
+  CheckPermissions,
+} from 'strapi-helper-plugin';
+
+import pluginId from '../../pluginId';
+import pluginPermissions from '../../permissions';
+import getTrad from '../../utils/getTrad';
+
+import Block from '../../components/Block';
+import Row from '../../components/Row';
+
+import openWithNewTab from '../../utils/openWithNewTab';
+import { ContainerFluid, StyledRow, VersionWrapper } from './components';
+// Actions
+import {
+  getDocInfos,
+  onChange,
+  onClickDeleteDoc,
+  onConfirmDeleteDoc,
+  onSubmit,
+  onUpdateDoc,
+} from './actions';
+// Selectors
+import selectHomePage from './selectors';
+import saga from './saga';
+
+export class HomePage extends React.Component {
+  static contextType = GlobalContext;
+
+  componentDidMount() {
+    this.props.getDocInfos();
+  }
+
+  getRestrictedAccessValue = () => {
+    const { form } = this.props;
+
+    return get(form, [0, 0, 'value'], false);
+  };
+
+  getPluginHeaderActions = () => {
+    const actions = [
+      {
+        color: 'none',
+        label: this.context.formatMessage({
+          id: getTrad('containers.HomePage.Button.open'),
+        }),
+        className: 'buttonOutline',
+        onClick: this.openCurrentDocumentation,
+        type: 'button',
+        key: 'button-open',
+        Component: props => (
+          <CheckPermissions permissions={pluginPermissions.open}>
+            <Button {...props} />
+          </CheckPermissions>
+        ),
+      },
+      {
+        label: this.context.formatMessage({
+          id: getTrad('containers.HomePage.Button.update'),
+        }),
+        color: 'success',
+        onClick: () => {},
+        type: 'submit',
+        key: 'button-submit',
+        Component: props => (
+          <CheckPermissions permissions={pluginPermissions.update}>
+            <Button {...props} />
+          </CheckPermissions>
+        ),
+      },
+    ];
+
+    return actions;
+  };
+
+  handleCopy = () => {
+    strapi.notification.toggle({
+      type: 'info',
+      message: { id: getTrad('containers.HomePage.copied') },
+    });
+  };
+
+  openCurrentDocumentation = () => {
+    const { currentDocVersion, prefix } = this.props;
+    const slash = prefix.startsWith('/') ? '' : '/';
+
+    return openWithNewTab(`${slash}${prefix}/v${currentDocVersion}`);
+  };
+
+  shouldHideInput = inputName => {
+    return !this.getRestrictedAccessValue() && inputName === 'password';
+  };
+
+  toggleModal = () => this.props.onClickDeleteDoc('');
+
+  renderForm = (array, i) => {
+    const { didCheckErrors, formErrors } = this.props;
+
+    return (
+      <div className="row" key={i}>
+        {array.map((input, j) => {
+          if (this.shouldHideInput(input.name)) {
+            return null;
+          }
+
+          return (
+            <Input
+              key={input.name}
+              {...input}
+              didCheckErrors={didCheckErrors}
+              errors={get(formErrors, [input.name], [])}
+              name={`form.${i}.${j}.value`}
+              onChange={this.props.onChange}
+            />
+          );
+        })}
+      </div>
+    );
+  };
+
+  renderRow = data => {
+    const { currentDocVersion, onClickDeleteDoc, onUpdateDoc } = this.props;
+
+    return (
+      <Row
+        currentDocVersion={currentDocVersion}
+        data={data}
+        key={data.generatedDate}
+        onClickDelete={onClickDeleteDoc}
+        onUpdateDoc={onUpdateDoc}
+      />
+    );
+  };
+
+  render() {
+    const {
+      docVersions,
+      form,
+      isLoading,
+      onConfirmDeleteDoc,
+      onSubmit,
+      versionToDelete,
+    } = this.props;
+
+    const { formatMessage } = this.context;
+
+    if (isLoading) {
+      return <LoadingIndicatorPage />;
+    }
+
+    return (
+      <ContainerFluid className="container-fluid">
+        <PopUpWarning
+          isOpen={!isEmpty(versionToDelete)}
+          toggleModal={this.toggleModal}
+          content={{
+            title: 'components.popUpWarning.title',
+            message: getTrad('containers.HomePage.PopUpWarning.message'),
+            cancel: 'app.components.Button.cancel',
+            confirm: getTrad('containers.HomePage.PopUpWarning.confirm'),
+          }}
+          popUpWarningType="danger"
+          onConfirm={onConfirmDeleteDoc}
+        />
+        <form onSubmit={onSubmit}>
+          <Header
+            actions={this.getPluginHeaderActions()}
+            title={{
+              label: formatMessage({
+                id: getTrad('containers.HomePage.PluginHeader.title'),
+              }),
+            }}
+            content={formatMessage({
+              id: getTrad('containers.HomePage.PluginHeader.description'),
+            })}
+          />
+          <StyledRow className="row">
+            <Block>
+              <CopyToClipboard text={auth.getToken()} onCopy={this.handleCopy}>
+                <div className="row" style={{ zIndex: '99' }}>
+                  <Input
+                    style={{ zIndex: '9', cursor: 'pointer' }}
+                    inputStyle={{ cursor: 'pointer' }}
+                    name="jwtToken"
+                    value={auth.getToken()}
+                    type="string"
+                    onChange={() => {}}
+                    label={{ id: getTrad('containers.HomePage.form.jwtToken') }}
+                    inputDescription={{
+                      id: getTrad('containers.HomePage.form.jwtToken.description'),
+                    }}
+                  />
+                </div>
+              </CopyToClipboard>
+            </Block>
+            <CheckPermissions permissions={pluginPermissions.update}>
+              <Block>{form.map(this.renderForm)}</Block>
+            </CheckPermissions>
+            <Block title={getTrad('containers.HomePage.Block.title')}>
+              <VersionWrapper>
+                <Row isHeader />
+                {docVersions.map(this.renderRow)}
+              </VersionWrapper>
+            </Block>
+          </StyledRow>
+        </form>
+      </ContainerFluid>
+    );
+  }
+}
+
+HomePage.defaultProps = {
+  currentDocVersion: '',
+  didCheckErrors: false,
+  docVersions: [],
+  form: [],
+  formErrors: {},
+  isLoading: true,
+  onChange: () => {},
+  onClickDeleteDoc: () => {},
+  onConfirmDeleteDoc: () => {},
+  onSubmit: () => {},
+  onUpdateDoc: () => {},
+  prefix: '/documentation',
+  versionToDelete: '',
+};
+
+HomePage.propTypes = {
+  currentDocVersion: PropTypes.string,
+  didCheckErrors: PropTypes.bool,
+  docVersions: PropTypes.array,
+  form: PropTypes.array,
+  formErrors: PropTypes.object,
+  getDocInfos: PropTypes.func.isRequired,
+  isLoading: PropTypes.bool,
+  onChange: PropTypes.func,
+  onClickDeleteDoc: PropTypes.func,
+  onConfirmDeleteDoc: PropTypes.func,
+  onSubmit: PropTypes.func,
+  onUpdateDoc: PropTypes.func,
+  prefix: PropTypes.string,
+  versionToDelete: PropTypes.string,
+};
+
+function mapDispatchToProps(dispatch) {
+  return bindActionCreators(
+    {
+      getDocInfos,
+      onChange,
+      onClickDeleteDoc,
+      onConfirmDeleteDoc,
+      onSubmit,
+      onUpdateDoc,
+    },
+    dispatch
+  );
+}
+
+const mapStateToProps = selectHomePage();
+
+const withConnect = connect(mapStateToProps, mapDispatchToProps);
+const withSaga = strapi.injectSaga({ key: 'homePage', saga, pluginId });
+
+export default compose(withSaga, withConnect)(HomePage);

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

@@ -0,0 +1,49 @@
+/*
+ *
+ * HomePage reducer
+ *
+ */
+
+import { fromJS, List } from 'immutable';
+import {
+  GET_DOC_INFOS_SUCCEEDED,
+  ON_CHANGE,
+  ON_CLICK_DELETE_DOC,
+  SET_FORM_ERRORS,
+} from './constants';
+
+const initialState = fromJS({
+  currentDocVersion: '',
+  didCheckErrors: false,
+  docVersions: List([]),
+  form: fromJS([]),
+  formErrors: fromJS({}),
+  isLoading: true,
+  prefix: '/documentation',
+  versionToDelete: '',
+});
+
+function homePageReducer(state = initialState, action) {
+  switch (action.type) {
+    case GET_DOC_INFOS_SUCCEEDED:
+      return state
+        .update('docVersions', () => List(action.data.docVersions))
+        .update('currentDocVersion', () => action.data.currentVersion)
+        .update('isLoading', () => false)
+        .update('prefix', () => action.data.prefix)
+        .update('form', () => fromJS(action.data.form))
+        .update('versionToDelete', () => '');
+    case ON_CHANGE:
+      return state.updateIn(action.keys, () => action.value);
+    case ON_CLICK_DELETE_DOC:
+      return state.update('versionToDelete', () => action.version);
+    case SET_FORM_ERRORS:
+      return state
+        .update('didCheckErrors', v => !v)
+        .update('formErrors', () => fromJS(action.errors));
+    default:
+      return state;
+  }
+}
+
+export default homePageReducer;

package/admin/src/containers/HomePage/saga.js

@@ -0,0 +1,126 @@
+import { cloneDeep, isArray } from 'lodash';
+import { all, takeLatest, put, fork, call, select } from 'redux-saga/effects';
+import { request } from 'strapi-helper-plugin';
+import { GET_DOC_INFOS, ON_CONFIRM_DELETE_DOC, ON_UPDATE_DOC, ON_SUBMIT } from './constants';
+import { getDocInfosSucceeded, setFormErrors } from './actions';
+import { makeSelectVersionToDelete, makeSelectPrefix, makeSelectForm } from './selectors';
+import getTrad from '../../utils/getTrad';
+
+/* eslint-disable consistent-return */
+
+function* getData() {
+  try {
+    const response = yield call(request, '/documentation/getInfos', {
+      method: 'GET',
+    });
+    yield put(getDocInfosSucceeded(response));
+  } catch (err) {
+    strapi.notification.toggle({
+      type: 'warning',
+      message: { id: 'notification.error' },
+    });
+  }
+}
+
+function* deleteDoc() {
+  try {
+    const prefix = yield select(makeSelectPrefix());
+    const version = yield select(makeSelectVersionToDelete());
+    const url = `${prefix}/deleteDoc/${version}`;
+    const response = yield call(request, url, { method: 'DELETE' });
+
+    if (response.ok) {
+      yield call(getData);
+      strapi.notification.toggle({
+        type: 'info',
+        message: { id: getTrad('notification.delete.success') },
+      });
+    }
+  } catch (err) {
+    strapi.notification.toggle({
+      type: 'warning',
+      message: err.response.payload.message,
+    });
+  }
+}
+
+function* submit() {
+  try {
+    const form = yield select(makeSelectForm());
+    const prefix = yield select(makeSelectPrefix());
+    const createBody = (data, init = {}) => {
+      return data.reduce((acc, current) => {
+        if (isArray(current)) {
+          return createBody(current, acc);
+        }
+
+        acc[current.name] = current.value;
+
+        return acc;
+      }, init);
+    };
+    const body = createBody(cloneDeep(form));
+
+    if (body.restrictedAccess && body.password === '') {
+      return yield put(
+        setFormErrors({
+          password: [{ id: 'components.Input.error.validation.required' }],
+        })
+      );
+    }
+
+    yield call(request, `${prefix}/updateSettings`, { method: 'PUT', body });
+    yield put(setFormErrors({}));
+
+    strapi.notification.toggle({
+      type: 'success',
+      message: { id: getTrad('notification.update.success') },
+    });
+  } catch (err) {
+    strapi.notification.toggle({
+      type: 'warning',
+      message: err.response.payload.message,
+    });
+  }
+}
+
+function* updateDoc(action) {
+  try {
+    const body = { version: action.version };
+    const prefix = yield select(makeSelectPrefix());
+    const response = yield call(request, `${prefix}/regenerateDoc`, {
+      method: 'POST',
+      body,
+    });
+
+    if (response.ok) {
+      yield call(getData);
+      strapi.notification.toggle({
+        type: 'info',
+        message: { id: getTrad('notification.generate.success') },
+      });
+    }
+  } catch (err) {
+    strapi.notification.toggle({
+      type: 'warning',
+      message: err.response.payload.message,
+    });
+  }
+}
+
+// Individual exports for testing
+export function* defaultSaga() {
+  try {
+    yield all([
+      fork(takeLatest, GET_DOC_INFOS, getData),
+      fork(takeLatest, ON_CONFIRM_DELETE_DOC, deleteDoc),
+      fork(takeLatest, ON_SUBMIT, submit),
+      fork(takeLatest, ON_UPDATE_DOC, updateDoc),
+    ]);
+  } catch (err) {
+    // Do nothing
+  }
+}
+
+// All sagas to be loaded
+export default defaultSaga;

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

@@ -0,0 +1,34 @@
+import { createSelector } from 'reselect';
+import pluginId from '../../pluginId';
+
+/**
+ * Direct selector to the homePage state domain
+ */
+const selectHomePageDomain = () => state => state.get(`${pluginId}_homePage`);
+
+/**
+ * Default selector used by HomePage
+ */
+
+const selectHomePage = () => createSelector(
+  selectHomePageDomain(),
+  (substate) => substate.toJS(),
+);
+
+const makeSelectForm = () => createSelector(
+  selectHomePageDomain(),
+  substate => substate.get('form').toJS(),
+);
+
+const makeSelectPrefix = () => createSelector(
+  selectHomePageDomain(),
+  substate => substate.get('prefix'),
+);
+
+const makeSelectVersionToDelete = () => createSelector(
+  selectHomePageDomain(),
+  substate => substate.get('versionToDelete'),
+);
+
+export default selectHomePage;
+export { makeSelectForm, makeSelectVersionToDelete, makeSelectPrefix };

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

@@ -0,0 +1,28 @@
+/**
+ *
+ * Initializer
+ *
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+
+import pluginId from '../../pluginId';
+
+class Initializer extends React.PureComponent {
+  // eslint-disable-line react/prefer-stateless-function
+  componentDidMount() {
+    // Emit the event 'pluginReady'
+    this.props.updatePlugin(pluginId, 'isReady', true);
+  }
+
+  render() {
+    return null;
+  }
+}
+
+Initializer.propTypes = {
+  updatePlugin: PropTypes.func.isRequired,
+};
+
+export default Initializer;

package/admin/src/containers/Initializer/tests/index.test.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { mount, shallow } from 'enzyme';
+
+import Initializer from '../index';
+
+describe('<Initializer />', () => {
+  it('Should not crash', () => {
+    const updatePlugin = jest.fn();
+    const renderedComponent = shallow(<Initializer updatePlugin={updatePlugin} />);
+
+    expect(renderedComponent.children()).toHaveLength(0);
+  });
+
+  it('should call the updatePlugin props when mounted', () => {
+    const updatePlugin = jest.fn();
+
+    const wrapper = mount(<Initializer updatePlugin={updatePlugin} />);
+
+    expect(wrapper.prop('updatePlugin')).toHaveBeenCalledWith('documentation', 'isReady', true);
+  });
+});

package/admin/src/index.js

@@ -0,0 +1,57 @@
+// NOTE TO PLUGINS DEVELOPERS:
+// If you modify this file by adding new options to the plugin entry point
+// Here's the file: strapi/docs/3.0.0-beta.x/plugin-development/frontend-field-api.md
+// Here's the file: strapi/docs/3.0.0-beta.x/guides/registering-a-field-in-admin.md
+// Also the strapi-generate-plugins/files/admin/src/index.js needs to be updated
+// IF THE DOC IS NOT UPDATED THE PULL REQUEST WILL NOT BE MERGED
+
+import pluginPkg from '../../package.json';
+import pluginPermissions from './permissions';
+import pluginId from './pluginId';
+import pluginLogo from './assets/images/logo.svg';
+import App from './containers/App';
+import Initializer from './containers/Initializer';
+import lifecycles from './lifecycles';
+import reducers from './reducers';
+import trads from './translations';
+
+export default strapi => {
+  const pluginDescription = pluginPkg.strapi.description || pluginPkg.description;
+  const icon = pluginPkg.strapi.icon;
+  const name = pluginPkg.strapi.name;
+  const plugin = {
+    blockerComponent: null,
+    blockerComponentProps: {},
+    description: pluginDescription,
+    icon,
+    id: pluginId,
+    initializer: Initializer,
+    injectedComponents: [],
+    isReady: false,
+    isRequired: pluginPkg.strapi.required || false,
+    layout: null,
+    lifecycles,
+    mainComponent: App,
+    name,
+    pluginLogo,
+    preventComponentRendering: false,
+    reducers,
+    trads,
+    menu: {
+      pluginsSectionLinks: [
+        {
+          destination: `/plugins/${pluginId}`,
+          icon,
+          label: {
+            id: `${pluginId}.plugin.name`,
+            defaultMessage: 'Documentation',
+          },
+          name,
+          permissions: pluginPermissions.main,
+        },
+      ],
+    },
+  };
+
+  return strapi.registerPlugin(plugin);
+};

package/admin/src/lifecycles.js

@@ -0,0 +1,13 @@
+/*
+ *
+ * SET THE HOOKS TO ENABLE THE MAGIC OF STRAPI.
+ * -------------------------------------------
+ *
+ * Secure, customise and enhance your project by setting
+ * the hooks via this file.
+ *
+ */
+
+function lifecycles() {}
+
+export default lifecycles;

package/admin/src/permissions.js

@@ -0,0 +1,19 @@
+const pluginPermissions = {
+  // This permission regards the main component (App) and is used to tell
+  // If the plugin link should be displayed in the menu
+  // And also if the plugin is accessible. This use case is found when a user types the url of the
+  // plugin directly in the browser
+  main: [
+    { action: 'plugins::documentation.read', subject: null },
+    { action: 'plugins::documentation.settings.regenerate', subject: null },
+    { action: 'plugins::documentation.settings.update', subject: null },
+  ],
+  open: [
+    { action: 'plugins::documentation.read', subject: null },
+    { action: 'plugins::documentation.settings.regenerate', subject: null },
+  ],
+  regenerate: [{ action: 'plugins::documentation.settings.regenerate', subject: null }],
+  update: [{ action: 'plugins::documentation.settings.update', subject: null }],
+};
+
+export default pluginPermissions;

package/admin/src/pluginId.js

@@ -0,0 +1,5 @@
+import pluginPkg from '../../package.json';
+
+const pluginId = pluginPkg.name.replace(/^strapi-plugin-/i, '');
+
+export default pluginId;

package/admin/src/reducers.js

@@ -0,0 +1,8 @@
+import homePageReducer from './containers/HomePage/reducer';
+import pluginId from './pluginId';
+
+const reducers = {
+  [`${pluginId}_homePage`]: homePageReducer,
+};
+
+export default reducers;

package/admin/src/translations/ar.json

@@ -0,0 +1,23 @@
+{
+  "components.Row.generatedDate": "Last generation",
+  "components.Row.open": "Open",
+  "components.Row.regenerate": "Regenerate",
+  "containers.HomePage.Block.title": "Versions",
+  "containers.HomePage.Button.open": "Open the documentation",
+  "containers.HomePage.Button.update": "Update",
+  "containers.HomePage.PluginHeader.description": "Configure the documentation plugin",
+  "containers.HomePage.PluginHeader.title": "Documentation - Settings",
+  "containers.HomePage.PopUpWarning.confirm": "I understand",
+  "containers.HomePage.PopUpWarning.message": "Are you sure you want to delete this version?",
+  "containers.HomePage.form.password": "Password",
+  "containers.HomePage.form.password.inputDescription": "Set the password to access the documentation",
+  "containers.HomePage.form.restrictedAccess": "Restricted access",
+  "containers.HomePage.form.restrictedAccess.inputDescription": "Make the documentation endpoint private. By default, the access is public",
+  "containers.HomePage.form.showGeneratedFiles": "Show generated files",
+  "containers.HomePage.form.showGeneratedFiles.inputDescription": "Useful when you want to override the generated documentation. \nThe plugin will generate files split by model and plugin. \nBy enabling this option it will be easier to customize your documentation",
+  "error.deleteDoc.versionMissing": "The version you are trying to delete does not exist.",
+  "error.noVersion": "A version is required",
+  "error.regenerateDoc": "An error occurred while regenerating the doc",
+  "error.regenerateDoc.versionMissing": "The version you are trying to generate doesn't exist",
+  "notification.update.success": "Settings updated successfully"
+}