Update group roles to owner/admin/user

app/soapbox/components/groups/group-avatar.tsx

@@ -1,7 +1,7 @@
 import clsx from 'clsx';
 import React from 'react';
 
-import { useGroupRoles } from 'soapbox/hooks/useGroupRoles';
+import { GroupRoles } from 'soapbox/schemas/group-member';
 
 import { Avatar } from '../ui';
 
@@ -16,17 +16,15 @@ interface IGroupAvatar {
 const GroupAvatar = (props: IGroupAvatar) => {
   const { group, size, withRing = false } = props;
 
-  const { normalizeRole } = useGroupRoles();
+  const isOwner = group.relationship?.role === GroupRoles.OWNER;
-
-  const isAdmin = normalizeRole(group.relationship?.role as any) === 'admin';
 
   return (
     <Avatar
       className={
         clsx('relative rounded-full', {
-          'shadow-[0_0_0_2px_theme(colors.primary.600),0_0_0_4px_theme(colors.white)]': isAdmin && withRing,
+          'shadow-[0_0_0_2px_theme(colors.primary.600),0_0_0_4px_theme(colors.white)]': isOwner && withRing,
-          'shadow-[0_0_0_2px_theme(colors.primary.600)]': isAdmin && !withRing,
+          'shadow-[0_0_0_2px_theme(colors.primary.600)]': isOwner && !withRing,
-          'shadow-[0_0_0_2px_theme(colors.white)]': !isAdmin && withRing,
+          'shadow-[0_0_0_2px_theme(colors.white)]': !isOwner && withRing,
         })
       }
       src={group.avatar}

app/soapbox/features/group/components/group-member-list-item.tsx

@@ -11,30 +11,28 @@ import { deleteEntities } from 'soapbox/entity-store/actions';
 import { Entities } from 'soapbox/entity-store/entities';
 import { useAccount, useAppDispatch, useFeatures } from 'soapbox/hooks';
 import { useBlockGroupMember, useDemoteGroupMember, usePromoteGroupMember } from 'soapbox/hooks/api';
-import { BaseGroupRoles, TruthSocialGroupRoles, useGroupRoles } from 'soapbox/hooks/useGroupRoles';
+import { GroupRoles } from 'soapbox/schemas/group-member';
 import toast from 'soapbox/toast';
 
 import type { Menu as IMenu } from 'soapbox/components/dropdown-menu';
 import type { Account as AccountEntity, Group, GroupMember } from 'soapbox/types/entities';
 
 const messages = defineMessages({
-  blockConfirm: { id: 'confirmations.block_from_group.confirm', defaultMessage: 'Block' },
+  blockConfirm: { id: 'confirmations.block_from_group.confirm', defaultMessage: 'Ban' },
   blockFromGroupHeading: { id: 'confirmations.block_from_group.heading', defaultMessage: 'Ban From Group' },
   blockFromGroupMessage: { id: 'confirmations.block_from_group.message', defaultMessage: 'Are you sure you want to ban @{name} from the group?' },
-  blocked: { id: 'group.group_mod_block.success', defaultMessage: 'You have successfully blocked @{name} from the group' },
+  blocked: { id: 'group.group_mod_block.success', defaultMessage: '@{name} is banned' },
-  demotedToUser: { id: 'group.group_mod_demote.success', defaultMessage: 'Demoted @{name} to group user' },
+  demotedToUser: { id: 'group.demote.user.success', defaultMessage: '@{name} is now a member' },
   groupModBlock: { id: 'group.group_mod_block', defaultMessage: 'Ban from group' },
   groupModDemote: { id: 'group.group_mod_demote', defaultMessage: 'Remove {role} role' },
   groupModKick: { id: 'group.group_mod_kick', defaultMessage: 'Kick @{name} from group' },
-  groupModPromoteAdmin: { id: 'group.group_mod_promote_admin', defaultMessage: 'Promote @{name} to group administrator' },
   groupModPromoteMod: { id: 'group.group_mod_promote_mod', defaultMessage: 'Assign {role} role' },
   kickConfirm: { id: 'confirmations.kick_from_group.confirm', defaultMessage: 'Kick' },
   kickFromGroupMessage: { id: 'confirmations.kick_from_group.message', defaultMessage: 'Are you sure you want to kick @{name} from this group?' },
   kicked: { id: 'group.group_mod_kick.success', defaultMessage: 'Kicked @{name} from group' },
-  promoteConfirm: { id: 'confirmations.promote_in_group.confirm', defaultMessage: 'Promote' },
+  promoteConfirm: { id: 'group.promote.admin.confirmation.title', defaultMessage: 'Assign Admin Role' },
-  promoteConfirmMessage: { id: 'confirmations.promote_in_group.message', defaultMessage: 'Are you sure you want to promote @{name}? You will not be able to demote them.' },
+  promoteConfirmMessage: { id: 'group.promote.admin.confirmation.message', defaultMessage: 'Are you sure you want to assign the admin role to @{name}?' },
-  promotedToAdmin: { id: 'group.group_mod_promote_admin.success', defaultMessage: 'Promoted @{name} to group administrator' },
+  promotedToAdmin: { id: 'group.promote.admin.success', defaultMessage: '@{name} is now an admin' },
-  promotedToMod: { id: 'group.group_mod_promote_mod.success', defaultMessage: 'You have successfully promoted @{name} to group {role}.' },
 });
 
 interface IGroupMemberListItem {
@@ -49,7 +47,6 @@ const GroupMemberListItem = (props: IGroupMemberListItem) => {
   const features = useFeatures();
   const intl = useIntl();
 
-  const { roles, isAdminRole, normalizeRole } = useGroupRoles();
   const blockGroupMember = useBlockGroupMember(group, member);
   const promoteGroupMember = usePromoteGroupMember(group, member);
   const demoteGroupMember = useDemoteGroupMember(group, member);
@@ -57,13 +54,13 @@ const GroupMemberListItem = (props: IGroupMemberListItem) => {
   const account = useAccount(member.account.id) as AccountEntity;
 
   // Current user role
-  const isCurrentUserAdmin = normalizeRole(group.relationship?.role as any) === BaseGroupRoles.ADMIN;
+  const isCurrentUserOwner = group.relationship?.role === GroupRoles.OWNER;
-  const isCurrentUserModerator = normalizeRole(group.relationship?.role as any) === BaseGroupRoles.MODERATOR;
+  const isCurrentUserAdmin = group.relationship?.role === GroupRoles.ADMIN;
 
   // Member role
-  const isMemberAdmin = normalizeRole(member.role as any) === BaseGroupRoles.ADMIN;
+  const isMemberOwner = member.role === GroupRoles.OWNER;
-  const isMemberModerator = normalizeRole(member.role as any) === BaseGroupRoles.MODERATOR;
+  const isMemberAdmin = member.role === GroupRoles.ADMIN;
-  const isMemberUser = normalizeRole(member.role as any) === BaseGroupRoles.USER;
+  const isMemberUser = member.role === GroupRoles.USER;
 
   const handleKickFromGroup = () => {
     dispatch(openModal('CONFIRM', {
@@ -91,44 +88,26 @@ const GroupMemberListItem = (props: IGroupMemberListItem) => {
     }));
   };
 
-  const onPromote = (role: TruthSocialGroupRoles | BaseGroupRoles, warning?: boolean) => {
+  const handleAdminAssignment = () => {
-    if (warning) {
+    dispatch(openModal('CONFIRM', {
-      return dispatch(openModal('CONFIRM', {
+      heading: intl.formatMessage(messages.promoteConfirm),
       message: intl.formatMessage(messages.promoteConfirmMessage, { name: account.username }),
       confirm: intl.formatMessage(messages.promoteConfirm),
+      confirmationTheme: 'primary',
       onConfirm: () => {
-          promoteGroupMember({ role: role, account_ids: [account.id] }, {
+        promoteGroupMember({ role: GroupRoles.ADMIN, account_ids: [account.id] }, {
           onSuccess() {
             toast.success(
-                intl.formatMessage(
+              intl.formatMessage(messages.promotedToAdmin, { name: account.acct }),
-                  isAdminRole(role) ? messages.promotedToAdmin : messages.promotedToMod, { name: account.acct, role },
-                ),
             );
           },
         });
       },
     }));
-    } else {
-      promoteGroupMember({ role: role, account_ids: [account.id] }, {
-        onSuccess() {
-          toast.success(
-            intl.formatMessage(
-              isAdminRole(role) ? messages.promotedToAdmin : messages.promotedToMod, { name: account.acct, role },
-            ),
-          );
-        },
-      });
-    }
   };
 
-  const handlePromoteToGroupAdmin = () => onPromote(roles.admin, true);
+  const handleUserAssignment = () => {
-
+    demoteGroupMember({ role: GroupRoles.USER, account_ids: [account.id] }, {
-  const handleAssignModerator = () => {
-    onPromote(roles.moderator, false);
-  };
-
-  const handleDemote = () => {
-    demoteGroupMember({ role: roles.user, account_ids: [account.id] }, {
       onSuccess() {
         toast.success(intl.formatMessage(messages.demotedToUser, { name: account.acct }));
       },
@@ -142,34 +121,26 @@ const GroupMemberListItem = (props: IGroupMemberListItem) => {
       return items;
     }
 
-    if (isCurrentUserAdmin && !isMemberAdmin && account.acct === account.username) {
+    if (isCurrentUserOwner) {
-      if (isMemberModerator) {
+      if (isMemberUser) {
-        if (features.groupsPromoteToAdmin) {
         items.push({
-            text: intl.formatMessage(messages.groupModPromoteAdmin, { name: account.username }),
+          text: intl.formatMessage(messages.groupModPromoteMod, { role: GroupRoles.ADMIN }),
-            icon: require('@tabler/icons/arrow-up-circle.svg'),
-            action: handlePromoteToGroupAdmin,
-          });
-        }
-
-        items.push({
-          text: intl.formatMessage(messages.groupModDemote, { role: roles.moderator, name: account.username }),
           icon: require('@tabler/icons/briefcase.svg'),
-          action: handleDemote,
+          action: handleAdminAssignment,
+        });
+      } else if (isMemberAdmin) {
+        items.push({
+          text: intl.formatMessage(messages.groupModDemote, { role: GroupRoles.ADMIN, name: account.username }),
+          icon: require('@tabler/icons/briefcase.svg'),
+          action: handleUserAssignment,
           destructive: true,
         });
-      } else if (isMemberUser) {
-        items.push({
-          text: intl.formatMessage(messages.groupModPromoteMod, { role: roles.moderator }),
-          icon: require('@tabler/icons/briefcase.svg'),
-          action: handleAssignModerator,
-        });
       }
     }
 
     if (
-      (isCurrentUserAdmin || isCurrentUserModerator) &&
+      (isCurrentUserOwner || isCurrentUserAdmin) &&
-      (isMemberModerator || isMemberUser) &&
+      (isMemberAdmin || isMemberUser) &&
       member.role !== group.relationship.role
     ) {
       if (features.groupsKick) {
@@ -198,12 +169,12 @@ const GroupMemberListItem = (props: IGroupMemberListItem) => {
       </div>
 
       <HStack alignItems='center' space={2}>
-        {(isMemberAdmin || isMemberModerator) ? (
+        {(isMemberOwner || isMemberAdmin) ? (
           <span
             className={
               clsx('inline-flex items-center rounded px-2 py-1 text-xs font-medium capitalize', {
-                'bg-primary-200 text-primary-500': isMemberAdmin,
+                'bg-primary-200 text-primary-500': isMemberOwner,
-                'bg-gray-200 text-gray-900': isMemberModerator,
+                'bg-gray-200 text-gray-900': isMemberAdmin,
               })
             }
           >

app/soapbox/features/group/group-members.tsx

@@ -2,8 +2,8 @@ import React, { useMemo } from 'react';
 
 import ScrollableList from 'soapbox/components/scrollable-list';
 import { useGroupMembers } from 'soapbox/hooks/api/useGroupMembers';
-import { useGroupRoles } from 'soapbox/hooks/useGroupRoles';
 import { useGroup } from 'soapbox/queries/groups';
+import { GroupRoles } from 'soapbox/schemas/group-member';
 
 import PlaceholderAccount from '../placeholder/components/placeholder-account';
 
@@ -16,22 +16,20 @@ interface IGroupMembers {
 }
 
 const GroupMembers: React.FC<IGroupMembers> = (props) => {
-  const { roles: { admin, moderator, user } } = useGroupRoles();
-
   const groupId = props.params.id;
 
   const { group, isFetching: isFetchingGroup } = useGroup(groupId);
-  const { groupMembers: admins, isFetching: isFetchingAdmins } = useGroupMembers(groupId, admin);
+  const { groupMembers: owners, isFetching: isFetchingOwners } = useGroupMembers(groupId, GroupRoles.OWNER);
-  const { groupMembers: moderators, isFetching: isFetchingModerators } = useGroupMembers(groupId, moderator);
+  const { groupMembers: admins, isFetching: isFetchingAdmins } = useGroupMembers(groupId, GroupRoles.ADMIN);
-  const { groupMembers: users, isFetching: isFetchingUsers, fetchNextPage, hasNextPage } = useGroupMembers(groupId, user);
+  const { groupMembers: users, isFetching: isFetchingUsers, fetchNextPage, hasNextPage } = useGroupMembers(groupId, GroupRoles.USER);
 
-  const isLoading = isFetchingGroup || isFetchingAdmins || isFetchingModerators || isFetchingUsers;
+  const isLoading = isFetchingGroup || isFetchingOwners || isFetchingAdmins || isFetchingUsers;
 
   const members = useMemo(() => [
+    ...owners,
     ...admins,
-    ...moderators,
     ...users,
-  ], [admins, moderators, users]);
+  ], [owners, admins, users]);
 
   return (
     <>

app/soapbox/hooks/useGroupRoles.ts

@@ -1,60 +0,0 @@
-import { TRUTHSOCIAL } from 'soapbox/utils/features';
-
-import { useBackend } from './useBackend';
-
-enum TruthSocialGroupRoles {
-  ADMIN = 'owner',
-  MODERATOR = 'admin',
-  USER = 'user'
-}
-
-enum BaseGroupRoles {
-  ADMIN = 'admin',
-  MODERATOR = 'moderator',
-  USER = 'user'
-}
-
-const roleMap = {
-  [TruthSocialGroupRoles.ADMIN]: BaseGroupRoles.ADMIN,
-  [TruthSocialGroupRoles.MODERATOR]: BaseGroupRoles.MODERATOR,
-  [TruthSocialGroupRoles.USER]: BaseGroupRoles.USER,
-};
-
-/**
- * Returns the correct role name depending on the used backend.
- *
- * @returns Object
- */
-const useGroupRoles = () => {
-  const version = useBackend();
-  const isTruthSocial = version.software === TRUTHSOCIAL;
-  const selectedRoles = isTruthSocial ? TruthSocialGroupRoles : BaseGroupRoles;
-
-  const isAdminRole = (role: TruthSocialGroupRoles | BaseGroupRoles) => {
-    if (isTruthSocial) {
-      return role === TruthSocialGroupRoles.ADMIN;
-    }
-
-    return role === BaseGroupRoles.ADMIN;
-  };
-
-  const normalizeRole = (role: TruthSocialGroupRoles) => {
-    if (isTruthSocial) {
-      return roleMap[role];
-    }
-
-    return role;
-  };
-
-  return {
-    isAdminRole,
-    normalizeRole,
-    roles: {
-      admin: selectedRoles.ADMIN,
-      moderator: selectedRoles.MODERATOR,
-      user: selectedRoles.USER,
-    },
-  };
-};
-
-export { useGroupRoles, TruthSocialGroupRoles, BaseGroupRoles };

app/soapbox/locales/en.json

@@ -470,8 +470,8 @@
   "confirmations.block.confirm": "Block",
   "confirmations.block.heading": "Block @{name}",
   "confirmations.block.message": "Are you sure you want to block {name}?",
-  "confirmations.block_from_group.confirm": "Block",
+  "confirmations.block_from_group.confirm": "Ban User",
-  "confirmations.block_from_group.heading": "Block group member",
+  "confirmations.block_from_group.heading": "Ban From Group",
   "confirmations.block_from_group.message": "Are you sure you want to ban @{name} from the group?",
   "confirmations.cancel.confirm": "Discard",
   "confirmations.cancel.heading": "Discard post",
@@ -771,7 +771,7 @@
   "group.group_mod_authorize": "Accept",
   "group.group_mod_authorize.success": "Accepted @{name} to group",
   "group.group_mod_block": "Ban from group",
-  "group.group_mod_block.success": "You have successfully blocked @{name} from the group",
+  "group.group_mod_block.success": "@{name} is banned",
   "group.group_mod_demote": "Remove {role} role",
   "group.group_mod_demote.success": "Demoted @{name} to group user",
   "group.group_mod_kick": "Kick @{name} from group",

app/soapbox/main.tsx

@@ -41,9 +41,9 @@ ready(() => {
 
   root.render(<Soapbox />);
 
-  if (BuildConfig.NODE_ENV === 'production') {
+  // if (BuildConfig.NODE_ENV === 'production') {
   // avoid offline in dev mode because it's harder to debug
   // https://github.com/NekR/offline-plugin/pull/201#issuecomment-285133572
   OfflinePluginRuntime.install();
-  }
+  // }
 });

app/soapbox/queries/groups/members.ts

@@ -1,14 +1,14 @@
 import { useQuery } from '@tanstack/react-query';
 
 import { useApi } from 'soapbox/hooks';
-import { useGroupRoles } from 'soapbox/hooks/useGroupRoles';
 import { normalizeAccount } from 'soapbox/normalizers';
+import { GroupRoles } from 'soapbox/schemas/group-member';
 
 const GroupMemberKeys = {
   members: (id: string, role: string) => ['group', id, role] as const,
 };
 
-const useGroupMembers = (groupId: string, role: ReturnType<typeof useGroupRoles>['roles']['admin']) => {
+const useGroupMembers = (groupId: string, role: GroupRoles) => {
   const api = useApi();
 
   const getQuery = async () => {

app/soapbox/schemas/group-member.ts

@@ -2,27 +2,18 @@ import z from 'zod';
 
 import { accountSchema } from './account';
 
-enum TruthSocialGroupRoles {
+enum GroupRoles {
-  ADMIN = 'owner',
+  OWNER = 'owner',
-  MODERATOR = 'admin',
-  USER = 'user'
-}
-
-enum BaseGroupRoles {
   ADMIN = 'admin',
-  MODERATOR = 'moderator',
   USER = 'user'
 }
 
 const groupMemberSchema = z.object({
   id: z.string(),
   account: accountSchema,
-  role: z.union([
+  role: z.nativeEnum(GroupRoles),
-    z.nativeEnum(TruthSocialGroupRoles),
-    z.nativeEnum(BaseGroupRoles),
-  ]),
 });
 
 type GroupMember = z.infer<typeof groupMemberSchema>;
 
-export { groupMemberSchema, GroupMember };
+export { groupMemberSchema, GroupMember, GroupRoles };