@strapi/admin 4.7.0-exp.3d6a31eb083e9d44afcf98f68c107fb7567e5720 → 4.7.0

package/ee/admin/hooks/useLicenseLimitNotification/index.js

@@ -0,0 +1,87 @@
+/**
+ *
+ * useLicenseLimitNotification
+ *
+ */
+import { useEffect } from 'react';
+import { useIntl } from 'react-intl';
+import { useLocation } from 'react-router';
+import { useNotification } from '@strapi/helper-plugin';
+import useLicenseLimits from '../useLicenseLimits';
+
+const STORAGE_KEY_PREFIX = 'strapi-notification-seat-limit';
+
+const BILLING_STRAPI_CLOUD_URL = 'https://cloud.strapi.io/profile/billing';
+const BILLING_SELF_HOSTED_URL = 'https://strapi.io/billing/request-seats';
+
+const useLicenseLimitNotification = () => {
+  const { formatMessage } = useIntl();
+  let { license } = useLicenseLimits();
+  const toggleNotification = useNotification();
+  const { pathname } = useLocation();
+
+  useEffect(() => {
+    if (!license?.data) {
+      return;
+    }
+
+    const { enforcementUserCount, permittedSeats, licenseLimitStatus, isHostedOnStrapiCloud } =
+      license?.data ?? {};
+
+    const shouldDisplayNotification =
+      permittedSeats &&
+      !window.sessionStorage.getItem(`${STORAGE_KEY_PREFIX}-${pathname}`) &&
+      (licenseLimitStatus === 'AT_LIMIT' || licenseLimitStatus === 'OVER_LIMIT');
+
+    let notificationType;
+
+    if (licenseLimitStatus === 'OVER_LIMIT') {
+      notificationType = 'warning';
+    } else if (licenseLimitStatus === 'AT_LIMIT') {
+      notificationType = 'softWarning';
+    }
+
+    if (shouldDisplayNotification) {
+      toggleNotification({
+        type: notificationType,
+        message: formatMessage(
+          {
+            id: 'notification.ee.warning.over-.message',
+            defaultMessage:
+              "Add seats to {licenseLimitStatus, select, OVER_LIMIT {invite} other {re-enable}} Users. If you already did it but it's not reflected in Strapi yet, make sure to restart your app.",
+          },
+          { licenseLimitStatus }
+        ),
+        title: formatMessage(
+          {
+            id: 'notification.ee.warning.at-seat-limit.title',
+            defaultMessage:
+              '{licenseLimitStatus, select, OVER_LIMIT {Over} other {At}} seat limit ({enforcementUserCount}/{permittedSeats})',
+          },
+          {
+            licenseLimitStatus,
+            enforcementUserCount,
+            permittedSeats,
+          }
+        ),
+        link: {
+          url: isHostedOnStrapiCloud ? BILLING_STRAPI_CLOUD_URL : BILLING_SELF_HOSTED_URL,
+          label: formatMessage(
+            {
+              id: 'notification.ee.warning.seat-limit.link',
+              defaultMessage:
+                '{isHostedOnStrapiCloud, select, true {ADD SEATS} other {CONTACT SALES}}',
+            },
+            { isHostedOnStrapiCloud }
+          ),
+        },
+        blockTransition: true,
+        onClose() {
+          window.sessionStorage.setItem(`${STORAGE_KEY_PREFIX}-${pathname}`, true);
+        },
+      });
+    }
+  }, [toggleNotification, license.data, pathname, formatMessage]);
+};
+
+export default useLicenseLimitNotification;

package/ee/admin/hooks/useLicenseLimits/index.js

@@ -0,0 +1,31 @@
+import { useFetchClient, useRBAC } from '@strapi/helper-plugin';
+import { useQuery } from 'react-query';
+import adminPermissions from '../../../../admin/src/permissions';
+
+const useLicenseLimits = () => {
+  const rbac = useRBAC(adminPermissions.settings.users);
+
+  const {
+    isLoading: isRBACLoading,
+    allowedActions: { canRead, canCreate, canUpdate, canDelete },
+  } = rbac;
+
+  const isRBACAllowed = canRead && canCreate && canUpdate && canDelete;
+
+  const { get } = useFetchClient();
+  const fetchLicenseLimitInfo = async () => {
+    const {
+      data: { data },
+    } = await get('/admin/license-limit-information');
+
+    return data;
+  };
+
+  const license = useQuery(['ee', 'license-limit-info'], fetchLicenseLimitInfo, {
+    enabled: !isRBACLoading && isRBACAllowed,
+  });
+
+  return { license };
+};
+
+export default useLicenseLimits;

package/ee/admin/pages/SettingsPage/pages/ApplicationInfosPage/components/AdminSeatInfo/index.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import { useIntl } from 'react-intl';
+import { Flex, Tooltip, Icon, GridItem, Typography, Stack } from '@strapi/design-system';
+import { Link } from '@strapi/design-system/v2';
+import { ExternalLink, ExclamationMarkCircle } from '@strapi/icons';
+import { pxToRem } from '@strapi/helper-plugin';
+import { useLicenseLimits } from '../../../../../../hooks';
+
+const BILLING_STRAPI_CLOUD_URL = 'https://cloud.strapi.io/profile/billing';
+const BILLING_SELF_HOSTED_URL = 'https://strapi.io/billing/request-seats';
+
+const AdminSeatInfo = () => {
+  const { formatMessage } = useIntl();
+  const { license } = useLicenseLimits();
+  const { licenseLimitStatus, enforcementUserCount, permittedSeats, isHostedOnStrapiCloud } =
+    license?.data ?? {};
+
+  if (!permittedSeats) {
+    return null;
+  }
+
+  return (
+    <GridItem col={6} s={12}>
+      <Typography variant="sigma" textColor="neutral600">
+        {formatMessage({
+          id: 'Settings.application.admin-seats',
+          defaultMessage: 'Admin seats',
+        })}
+      </Typography>
+      <Stack spacing={2} horizontal>
+        <Flex>
+          <Typography as="p">
+            {formatMessage(
+              {
+                id: 'Settings.application.ee.admin-seats.count',
+                defaultMessage: '<text>{enforcementUserCount}</text>/{permittedSeats}',
+              },
+              {
+                permittedSeats,
+                enforcementUserCount,
+                // eslint-disable-next-line react/no-unstable-nested-components
+                text: (chunks) => (
+                  <Typography
+                    fontWeight="semiBold"
+                    textColor={enforcementUserCount > permittedSeats ? 'danger500' : null}
+                  >
+                    {chunks}
+                  </Typography>
+                ),
+              }
+            )}
+          </Typography>
+        </Flex>
+        {licenseLimitStatus === 'OVER_LIMIT' && (
+          <Tooltip
+            description={formatMessage({
+              id: 'Settings.application.ee.admin-seats.at-limit-tooltip',
+              defaultMessage: 'At limit: add seats to invite more users',
+            })}
+          >
+            <Icon
+              width={`${pxToRem(14)}rem`}
+              height={`${pxToRem(14)}rem`}
+              color="danger500"
+              as={ExclamationMarkCircle}
+            />
+          </Tooltip>
+        )}
+      </Stack>
+      <Link
+        href={isHostedOnStrapiCloud ? BILLING_STRAPI_CLOUD_URL : BILLING_SELF_HOSTED_URL}
+        isExternal
+        endIcon={<ExternalLink />}
+      >
+        {formatMessage(
+          {
+            id: 'Settings.application.ee.admin-seats.add-seats',
+            defaultMessage:
+              '{isHostedOnStrapiCloud, select, true {Add seats} other {Contact sales}}',
+          },
+          { isHostedOnStrapiCloud }
+        )}
+      </Link>
+    </GridItem>
+  );
+};
+
+export default AdminSeatInfo;

package/ee/admin/pages/SettingsPage/pages/AuditLogs/ListView/Modal/ActionBody.js

@@ -64,7 +64,7 @@ const ActionBody = ({ status, data, formattedDate }) => {
             id: 'Settings.permissions.auditLogs.user',
             defaultMessage: 'User',
           })}
-          actionName={user?.fullname || '-'}
+          actionName={user?.displayName || '-'}
         />
         <ActionItem
           actionLabel={formatMessage({

package/ee/admin/pages/SettingsPage/pages/AuditLogs/ListView/utils/getDisplayedFilters.js

@@ -13,6 +13,26 @@ const customOperators = [
 ];
 
 const getDisplayedFilters = ({ formatMessage, users }) => {
+  const getDisplaynameFromUser = (user) => {
+    if (user.username) {
+      return user.username;
+    }
+    if (user.firstname && user.lastname) {
+      return formatMessage(
+        {
+          id: 'Settings.permissions.auditLogs.user.fullname',
+          defaultMessage: '{firstname} {lastname}',
+        },
+        {
+          firstname: user.firstname,
+          lastname: user.lastname,
+        }
+      );
+    }
+
+    return user.email;
+  };
+
   const actionOptions = Object.keys(actionTypes).map((action) => {
     return {
       label: formatMessage(
@@ -30,16 +50,7 @@ const getDisplayedFilters = ({ formatMessage, users }) => {
     users &&
     users.results.map((user) => {
       return {
-        label: formatMessage(
-          {
-            id: 'Settings.permissions.auditLogs.user.fullname',
-            defaultMessage: '{firstname} {lastname}',
-          },
-          {
-            firstname: user.firstname,
-            lastname: user.lastname,
-          }
-        ),
+        label: getDisplaynameFromUser(user),
         // Combobox expects a string value
         customValue: user.id.toString(),
       };

package/ee/admin/pages/SettingsPage/pages/AuditLogs/ListView/utils/tableHeaders.js

@@ -31,7 +31,7 @@ const tableHeaders = [
       },
       sortable: false,
     },
-    cellFormatter: (user) => (user ? user.fullname : ''),
+    cellFormatter: (user) => (user ? user.displayName : ''),
   },
 ];
 

package/ee/admin/pages/SettingsPage/pages/Users/ListPage/CreateAction/index.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import { useIntl } from 'react-intl';
+import PropTypes from 'prop-types';
+import { Stack, Button, Tooltip, Icon } from '@strapi/design-system';
+import { Envelop, ExclamationMarkCircle } from '@strapi/icons';
+import { useLicenseLimits } from '../../../../../../hooks';
+
+const CreateAction = ({ onClick }) => {
+  const { formatMessage } = useIntl();
+  const { license } = useLicenseLimits();
+  const { permittedSeats, shouldStopCreate } = license?.data ?? {};
+
+  return (
+    <Stack spacing={2} horizontal>
+      {permittedSeats && shouldStopCreate && (
+        <Tooltip
+          description={formatMessage({
+            id: 'Settings.application.admin-seats.at-limit-tooltip',
+            defaultMessage: 'At limit: add seats to invite more users',
+          })}
+          position="left"
+        >
+          <Icon
+            width={`${14 / 16}rem`}
+            height={`${14 / 16}rem`}
+            color="danger500"
+            as={ExclamationMarkCircle}
+          />
+        </Tooltip>
+      )}
+      <Button
+        data-testid="create-user-button"
+        onClick={onClick}
+        startIcon={<Envelop />}
+        size="S"
+        disabled={shouldStopCreate}
+      >
+        {formatMessage({
+          id: 'Settings.permissions.users.create',
+          defaultMessage: 'Invite new user',
+        })}
+      </Button>
+    </Stack>
+  );
+};
+
+CreateAction.propTypes = {
+  onClick: PropTypes.func.isRequired,
+};
+
+export default CreateAction;

package/ee/server/bootstrap.js

@@ -17,7 +17,7 @@ module.exports = async () => {
     await actionProvider.registerMany(actions.auditLogs);
   }
 
-  // TODO: check admin seats
+  await getService('seat-enforcement').seatEnforcementWorkflow();
 
   await executeCEBootstrap();
 };

package/ee/server/controllers/admin.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// eslint-disable-next-line node/no-extraneous-require
+const ee = require('@strapi/strapi/lib/utils/ee');
+const { env } = require('@strapi/utils');
+const { getService } = require('../../../server/utils');
+
+module.exports = {
+  async licenseLimitInformation() {
+    const permittedSeats = ee.seats;
+
+    let shouldNotify = false;
+    let licenseLimitStatus = null;
+    let enforcementUserCount;
+
+    const currentActiveUserCount = await getService('user').getCurrentActiveUserCount();
+
+    const eeDisabledUsers = await getService('seat-enforcement').getDisabledUserList();
+
+    if (eeDisabledUsers) {
+      enforcementUserCount = currentActiveUserCount + eeDisabledUsers.length;
+    } else {
+      enforcementUserCount = currentActiveUserCount;
+    }
+
+    if (enforcementUserCount > permittedSeats) {
+      shouldNotify = true;
+      licenseLimitStatus = 'OVER_LIMIT';
+    }
+
+    if (enforcementUserCount === permittedSeats) {
+      shouldNotify = true;
+      licenseLimitStatus = 'AT_LIMIT';
+    }
+
+    const data = {
+      enforcementUserCount,
+      currentActiveUserCount,
+      permittedSeats,
+      shouldNotify,
+      shouldStopCreate: currentActiveUserCount >= permittedSeats,
+      licenseLimitStatus,
+      isHostedOnStrapiCloud: env('STRAPI_HOSTING', null) === 'strapi.cloud',
+    };
+
+    return { data };
+  },
+};

package/ee/server/controllers/index.js

@@ -6,4 +6,5 @@ module.exports = {
   role: require('./role'),
   user: require('./user'),
   auditLogs: require('./audit-logs'),
+  admin: require('./admin'),
 };

package/ee/server/controllers/user.js

@@ -1,17 +1,44 @@
 'use strict';
 
-const { get } = require('lodash');
+// eslint-disable-next-line node/no-extraneous-require
+const ee = require('@strapi/strapi/lib/utils/ee');
+const _ = require('lodash');
 const { pick } = require('lodash/fp');
-const { ApplicationError } = require('@strapi/utils').errors;
+const { ApplicationError, ForbiddenError } = require('@strapi/utils').errors;
 const { validateUserCreationInput } = require('../validation/user');
+const {
+  validateUserUpdateInput,
+  validateUsersDeleteInput,
+} = require('../../../server/validation/user');
 const { getService } = require('../../../server/utils');
 
 const pickUserCreationAttributes = pick(['firstname', 'lastname', 'email', 'roles']);
 
+const hasAdminSeatsAvaialble = async () => {
+  if (!strapi.EE) {
+    return true;
+  }
+
+  const permittedSeats = ee.seats;
+  if (!permittedSeats) {
+    return true;
+  }
+
+  const userCount = await strapi.service('admin::user').getCurrentActiveUserCount();
+
+  if (userCount < permittedSeats) {
+    return true;
+  }
+};
+
 module.exports = {
   async create(ctx) {
+    if (!(await hasAdminSeatsAvaialble())) {
+      throw new ForbiddenError('License seat limit reached. You cannot create a new user');
+    }
+
     const { body } = ctx.request;
-    const cleanData = { ...body, email: get(body, `email`, ``).toLowerCase() };
+    const cleanData = { ...body, email: _.get(body, `email`, ``).toLowerCase() };
 
     await validateUserCreationInput(cleanData);
 
@@ -37,4 +64,69 @@ module.exports = {
 
     ctx.created({ data: userInfo });
   },
+
+  async update(ctx) {
+    const { id } = ctx.params;
+    const { body: input } = ctx.request;
+
+    await validateUserUpdateInput(input);
+
+    if (_.has(input, 'email')) {
+      const uniqueEmailCheck = await getService('user').exists({
+        id: { $ne: id },
+        email: input.email,
+      });
+
+      if (uniqueEmailCheck) {
+        throw new ApplicationError('A user with this email address already exists');
+      }
+    }
+
+    const user = await getService('user').findOne(id, null);
+
+    if (!(await hasAdminSeatsAvaialble()) && !user.isActive && input.isActive) {
+      throw new ForbiddenError('License seat limit reached. You cannot active this user');
+    }
+
+    const updatedUser = await getService('user').updateById(id, input);
+
+    if (!updatedUser) {
+      return ctx.notFound('User does not exist');
+    }
+
+    ctx.body = {
+      data: getService('user').sanitizeUser(updatedUser),
+    };
+  },
+
+  async deleteOne(ctx) {
+    const { id } = ctx.params;
+
+    const deletedUser = await getService('user').deleteById(id);
+
+    if (!deletedUser) {
+      return ctx.notFound('User not found');
+    }
+
+    return ctx.deleted({
+      data: getService('user').sanitizeUser(deletedUser),
+    });
+  },
+
+  /**
+   * Delete several users
+   * @param {KoaContext} ctx - koa context
+   */
+  async deleteMany(ctx) {
+    const { body } = ctx.request;
+    await validateUsersDeleteInput(body);
+
+    const users = await getService('user').deleteByIds(body.ids);
+
+    const sanitizedUsers = users.map(getService('user').sanitizeUser);
+
+    return ctx.deleted({
+      data: sanitizedUsers,
+    });
+  },
 };

package/ee/server/routes/index.js

@@ -148,4 +148,27 @@ module.exports = [
       ],
     },
   },
+
+  // License limit infos
+  {
+    method: 'GET',
+    path: '/license-limit-information',
+    handler: 'admin.licenseLimitInformation',
+    config: {
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: [
+              'admin::users.create',
+              'admin::users.read',
+              'admin::users.update',
+              'admin::users.delete',
+            ],
+          },
+        },
+      ],
+    },
+  },
 ];

package/ee/server/services/audit-logs.js

@@ -37,11 +37,21 @@ const defaultEvents = [
   'permission.delete',
 ];
 
-const getSanitizedUser = (user) => ({
-  id: user.id,
-  email: user.email,
-  fullname: `${user.firstname} ${user.lastname}`,
-});
+const getSanitizedUser = (user) => {
+  let displayName = user.email;
+
+  if (user.username) {
+    displayName = user.username;
+  } else if (user.firstname && user.lastname) {
+    displayName = `${user.firstname} ${user.lastname}`;
+  }
+
+  return {
+    id: user.id,
+    email: user.email,
+    displayName,
+  };
+};
 
 const getEventMap = (defaultEvents) => {
   const getDefaultPayload = (...args) => args[0];

package/ee/server/services/index.js

@@ -3,4 +3,6 @@
 module.exports = {
   passport: require('./passport'),
   role: require('./role'),
+  user: require('./user'),
+  'seat-enforcement': require('./seat-enforcement'),
 };

package/ee/server/services/seat-enforcement.js

@@ -0,0 +1,114 @@
+'use strict';
+
+// eslint-disable-next-line node/no-extraneous-require
+const ee = require('@strapi/strapi/lib/utils/ee');
+const { take, drop, map, prop, pick, reverse } = require('lodash/fp');
+const { getService } = require('../../../server/utils');
+const { SUPER_ADMIN_CODE } = require('../../../server/services/constants');
+
+/**
+ * Keeps the list of users disabled by the seat enforcement service
+ */
+const getDisabledUserList = async () => {
+  return strapi.store.get({ type: 'ee', key: 'disabled_users' });
+};
+
+const enableMaximumUserCount = async (numberOfUsersToEnable) => {
+  const disabledUsers = await getDisabledUserList();
+  const orderedDisabledUsers = reverse(disabledUsers);
+
+  const usersToEnable = take(numberOfUsersToEnable, orderedDisabledUsers);
+
+  await strapi.db.query('admin::user').updateMany({
+    where: { id: map(prop('id'), usersToEnable) },
+    data: { isActive: true },
+  });
+
+  const remainingDisabledUsers = drop(numberOfUsersToEnable, orderedDisabledUsers);
+
+  await strapi.store.set({
+    type: 'ee',
+    key: 'disabled_users',
+    value: remainingDisabledUsers,
+  });
+};
+
+const disableUsersAboveLicenseLimit = async (numberOfUsersToDisable) => {
+  const currentlyDisabledUsers = (await getDisabledUserList()) ?? [];
+
+  const usersToDisable = [];
+  const nonSuperAdminUsersToDisable = await strapi.db.query('admin::user').findMany({
+    where: {
+      isActive: true,
+      roles: {
+        code: { $ne: SUPER_ADMIN_CODE },
+      },
+    },
+    orderBy: { createdAt: 'DESC' },
+    limit: numberOfUsersToDisable,
+  });
+
+  usersToDisable.push(...nonSuperAdminUsersToDisable);
+
+  if (nonSuperAdminUsersToDisable.length < numberOfUsersToDisable) {
+    const superAdminUsersToDisable = await strapi.db.query('admin::user').findMany({
+      where: {
+        isActive: true,
+        roles: { code: SUPER_ADMIN_CODE },
+      },
+      orderBy: { createdAt: 'DESC' },
+      limit: numberOfUsersToDisable - nonSuperAdminUsersToDisable.length,
+    });
+
+    usersToDisable.push(...superAdminUsersToDisable);
+  }
+
+  await strapi.db.query('admin::user').updateMany({
+    where: { id: map(prop('id'), usersToDisable) },
+    data: { isActive: false },
+  });
+
+  await strapi.store.set({
+    type: 'ee',
+    key: 'disabled_users',
+    value: currentlyDisabledUsers.concat(map(pick(['id', 'isActive']), usersToDisable)),
+  });
+};
+
+const syncDisabledUserRecords = async () => {
+  const disabledUsers = await strapi.store.get({ type: 'ee', key: 'disabled_users' });
+
+  if (!disabledUsers) {
+    return;
+  }
+
+  await strapi.db.query('admin::user').updateMany({
+    where: { id: map(prop('id'), disabledUsers) },
+    data: { isActive: false },
+  });
+};
+
+const seatEnforcementWorkflow = async () => {
+  const adminSeats = ee.seats;
+  if (!adminSeats) {
+    return;
+  }
+
+  // TODO: we need to make sure an admin can decide to disable specific user and reactivate others
+  await syncDisabledUserRecords();
+
+  const currentActiveUserCount = await getService('user').getCurrentActiveUserCount();
+
+  const adminSeatsLeft = adminSeats - currentActiveUserCount;
+
+  if (adminSeatsLeft > 0) {
+    await enableMaximumUserCount(adminSeatsLeft);
+  } else if (adminSeatsLeft < 0) {
+    await disableUsersAboveLicenseLimit(-adminSeatsLeft);
+  }
+};
+
+module.exports = {
+  seatEnforcementWorkflow,
+  getDisabledUserList,
+};