Implemented delete

packages/app/src/components/Admin/UserGroup/UserGroupDeleteModal.tsx

@@ -102,7 +102,7 @@ const UserGroupDeleteModal: FC<Props> = (props: Props) => {
   const handleActionChange = useCallback((e) => {
     const actionName = e.target.value;
     setActionName(actionName);
-  }, []);
+  }, [setActionName]);
 
   const handleGroupChange = useCallback((e) => {
     const transferToUserGroupId = e.target.value;
@@ -121,10 +121,10 @@ const UserGroupDeleteModal: FC<Props> = (props: Props) => {
       actionName,
       transferToUserGroupId,
     );
-  }, [props.onDelete, props.deleteUserGroup]);
+  }, [props.onDelete, props.deleteUserGroup, actionName, transferToUserGroupId]);
 
   const renderPageActionSelector = useCallback(() => {
-    const optoins = availableOptions.map((opt) => {
+    const options = availableOptions.map((opt) => {
       const dataContent = `<i class="icon icon-fw ${opt.iconClass} ${opt.styleClass}"></i> <span class="action-name ${opt.styleClass}">${opt.label}</span>`;
       return <option key={opt.id} value={opt.actionForPages} data-content={dataContent}>{opt.label}</option>;
     });
@@ -138,10 +138,10 @@ const UserGroupDeleteModal: FC<Props> = (props: Props) => {
         onChange={handleActionChange}
       >
         <option value="" disabled>{t('admin:user_group_management.delete_modal.dropdown_desc')}</option>
-        {optoins}
+        {options}
       </select>
     );
-  }, [handleActionChange]);
+  }, [handleActionChange, actionName, availableOptions]);
 
   const renderGroupSelector = useCallback(() => {
     const { deleteUserGroup } = props;

packages/app/src/components/Admin/UserGroup/UserGroupPage.tsx

@@ -97,10 +97,10 @@ const UserGroupPage: FC<Props> = (props: Props) => {
       setSelectedUserGroup(undefined);
       setDeleteModalShown(false);
 
-      toastSuccess(`Deleted a group "${xss.process(res.data.userGroup.name)}"`);
+      toastSuccess(`Deleted ${xss.process(res.data.userGroups.length)} groups.`);
     }
     catch (err) {
-      toastError(new Error('Unable to delete the group'));
+      toastError(new Error('Unable to delete the groups'));
     }
   }, [mutateUserGroups, mutateUserGroupRelations]);
 

packages/app/src/components/Admin/UserGroup/UserGroupTable.tsx

@@ -133,15 +133,15 @@ const UserGroupTable: FC<Props> = (props: Props) => {
                   <ul className="list-inline">
                     {groupIdToChildGroupsMap[group._id] != null && groupIdToChildGroupsMap[group._id].map((group) => {
                       return (
-                        <li key={group._id} className="list-inline-item badge badge-pill badge-warning">
+                        <li key={group._id} className="list-inline-item badge badge-success">
                           {props.isAclEnabled
                             ? (
-                              <td><a href={`/admin/user-group-detail/${group._id}`}>{xss.process(group.name)}</a></td>
+                              <a href={`/admin/user-group-detail/${group._id}`}>{xss.process(group.name)}</a>
                             )
                             : (
-                              <td>{xss.process(group.name)}</td>
+                              <p>{xss.process(group.name)}</p>
                             )
-                          },&nbsp;
+                          }
                         </li>
                       );
                     })}

packages/app/src/server/models/obsolete-page.js

@@ -1121,24 +1121,29 @@ export const getPageSchema = (crowi) => {
     return await queryBuilder.query.exec();
   };
 
-  pageSchema.statics.publicizePage = async function(page) {
-    page.grantedGroup = null;
-    page.grant = GRANT_PUBLIC;
-    await page.save();
+  pageSchema.statics.publicizePages = async function(pages) {
+    const operationsToPublicize = pages.map((page) => {
+      return {
+        updateOne: {
+          filter: { _id: page._id },
+          update: {
+            grantedGroup: null,
+            grant: this.GRANT_PUBLIC,
+          },
+        },
+      };
+    });
+    await this.bulkWrite(operationsToPublicize);
   };
 
-  pageSchema.statics.transferPageToGroup = async function(page, transferToUserGroupId) {
+  pageSchema.statics.transferPagesToGroup = async function(pages, transferToUserGroupId) {
     const UserGroup = mongoose.model('UserGroup');
 
-    // check page existence
-    const isExist = await UserGroup.count({ _id: transferToUserGroupId }) > 0;
-    if (isExist) {
-      page.grantedGroup = transferToUserGroupId;
-      await page.save();
-    }
-    else {
-      throw new Error('Cannot find the group to which private pages belong to. _id: ', transferToUserGroupId);
+    if ((await UserGroup.count({ _id: transferToUserGroupId })) === 0) {
+      throw Error('Cannot find the group to which private pages belong to. _id: ', transferToUserGroupId);
     }
+
+    await this.updateMany({ _id: { $in: pages.map(p => p._id) } }, { grantedGroup: transferToUserGroupId });
   };
 
   /**

packages/app/src/server/models/user-group-relation.js

@@ -248,8 +248,12 @@ class UserGroupRelation {
    * @returns {Promise<any>}
    * @memberof UserGroupRelation
    */
-  static removeAllByUserGroup(userGroup) {
-    return this.deleteMany({ relatedGroup: userGroup });
+  static removeAllByUserGroups(groupsToDelete) {
+    if (!Array.isArray(groupsToDelete)) {
+      throw Error('groupsToDelete must be an array.');
+    }
+
+    return this.deleteMany({ relatedGroup: { $in: groupsToDelete } });
   }
 
   /**

packages/app/src/server/models/user-group.js

@@ -97,22 +97,35 @@ class UserGroup {
     };
   }
 
+  static async findGroupsWithDescendantsRecursively(groups, descendants = groups) {
+    const nextGroups = await this.find({ parent: { $in: groups.map(g => g._id) } });
+
+    if (nextGroups.length === 0) {
+      return descendants;
+    }
+
+    return this.findAllAncestorGroups(nextGroups, descendants.concat(nextGroups));
+  }
+
   // Delete completely
-  static async removeCompletelyById(deleteGroupId, action, transferToUserGroupId, user) {
+  static async removeCompletelyByRootGroupId(deleteRootGroupId, action, transferToUserGroupId, user) {
     const UserGroupRelation = mongoose.model('UserGroupRelation');
 
-    const groupToDelete = await this.findById(deleteGroupId);
-    if (groupToDelete == null) {
-      throw new Error('UserGroup data is not exists. id:', deleteGroupId);
+    const rootGroup = await this.findById(deleteRootGroupId);
+    if (rootGroup == null) {
+      throw new Error('UserGroup data is not exists. id:', rootGroup._id);
     }
-    const deletedGroup = await groupToDelete.remove();
 
-    await Promise.all([
-      UserGroupRelation.removeAllByUserGroup(deletedGroup),
-      UserGroup.crowi.pageService.handlePrivatePagesForDeletedGroup(deletedGroup, action, transferToUserGroupId, user),
-    ]);
+    const groupsToDelete = await this.findGroupsWithDescendantsRecursively([rootGroup]);
+
+    // 1. update page & remove all groups
+    await UserGroup.crowi.pageService.handlePrivatePagesForGroupsToDelete(groupsToDelete, action, transferToUserGroupId, user);
+    // 2. remove all groups
+    const deletedGroups = await this.deleteMany({ _id: { $in: groupsToDelete.map(g => g._id) } });
+    // 3. remove all relations
+    await UserGroupRelation.removeAllByUserGroups(groupsToDelete);
 
-    return deletedGroup;
+    return deletedGroups;
   }
 
   static countUserGroups() {

packages/app/src/server/routes/apiv3/user-group.js

@@ -209,14 +209,14 @@ module.exports = (crowi) => {
     const { actionName, transferToUserGroupId } = req.query;
 
     try {
-      const userGroup = await UserGroup.removeCompletelyById(deleteGroupId, actionName, transferToUserGroupId, req.user);
+      const userGroups = await UserGroup.removeCompletelyByRootGroupId(deleteGroupId, actionName, transferToUserGroupId, req.user);
 
-      return res.apiv3({ userGroup });
+      return res.apiv3({ userGroups });
     }
     catch (err) {
-      const msg = 'Error occurred in deleting a user group';
+      const msg = 'Error occurred while deleting user groups';
       logger.error(msg, err);
-      return res.apiv3Err(new ErrorV3(msg, 'user-group-delete-failed'));
+      return res.apiv3Err(new ErrorV3(msg, 'user-groups-delete-failed'));
     }
   });
 

packages/app/src/server/service/page.js

@@ -829,22 +829,19 @@ class PageService {
   }
 
 
-  async handlePrivatePagesForDeletedGroup(deletedGroup, action, transferToUserGroupId, user) {
+  async handlePrivatePagesForGroupsToDelete(groupsToDelete, action, transferToUserGroupId, user) {
     const Page = this.crowi.model('Page');
-    const pages = await Page.find({ grantedGroup: deletedGroup });
+    const pages = await Page.find({ grantedGroup: { $in: groupsToDelete } });
 
+    let operationsToPublicize;
     switch (action) {
       case 'public':
-        await Promise.all(pages.map((page) => {
-          return Page.publicizePage(page);
-        }));
+        await Page.publicizePages(pages);
         break;
       case 'delete':
         return this.deleteMultipleCompletely(pages, user);
       case 'transfer':
-        await Promise.all(pages.map((page) => {
-          return Page.transferPageToGroup(page, transferToUserGroupId);
-        }));
+        await Page.transferPagesToGroup(pages, transferToUserGroupId);
         break;
       default:
         throw new Error('Unknown action for private pages');

packages/app/src/stores/user-group.tsx

@@ -35,8 +35,8 @@ export const useSWRxUserGroupRelationList = (
 ): SWRResponse<IUserGroupRelationHasId[], Error> => {
   return useSWRImmutable<IUserGroupRelationHasId[], Error>(
     groupIds != null ? ['/user-group-relations', groupIds, childGroupIds] : null,
-    (endpoint, parentIds, childGroupIds) => apiv3Get<UserGroupRelationListResult>(
-      endpoint, { parentIds, childGroupIds },
+    (endpoint, groupIds, childGroupIds) => apiv3Get<UserGroupRelationListResult>(
+      endpoint, { groupIds, childGroupIds },
     ).then(result => result.data.userGroupRelations),
     {
       fallbackData: initialData,