Skip to content

Commit c5512ce

Browse files
freya022freya022
committed
Move command permissions logic to helpers
1 parent 79cc4e2 commit c5512ce

7 files changed

+363
-177
lines changed

‎src/main/java/net/dv8tion/jda/api/interactions/commands/PrivilegeConfig.java

+5-177
Original file line numberDiff line numberDiff line change
@@ -20,19 +20,18 @@
2020
import net.dv8tion.jda.api.Permission;
2121
import net.dv8tion.jda.api.entities.Guild;
2222
import net.dv8tion.jda.api.entities.Member;
23-
import net.dv8tion.jda.api.entities.Role;
2423
import net.dv8tion.jda.api.entities.SelfUser;
2524
import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
2625
import net.dv8tion.jda.api.interactions.commands.privileges.IntegrationPrivilege;
2726
import net.dv8tion.jda.internal.utils.Checks;
28-
import net.dv8tion.jda.internal.utils.PermissionUtil;
27+
import net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper;
2928
import org.jetbrains.annotations.Unmodifiable;
3029

3130
import javax.annotation.Nonnull;
3231
import javax.annotation.Nullable;
33-
import java.util.*;
34-
import java.util.function.Predicate;
35-
import java.util.stream.Collectors;
32+
import java.util.Collections;
33+
import java.util.List;
34+
import java.util.Map;
3635

3736
/**
3837
* A PrivilegeConfig is the collection of moderator defined {@link IntegrationPrivilege privileges} set on a specific application and its commands
@@ -171,177 +170,6 @@ public boolean canMemberRun(@Nonnull GuildChannel channel, @Nonnull Member membe
171170
Checks.notNull(channel, "Channel");
172171
Checks.notNull(member, "Member");
173172
Checks.notNull(command, "Command");
174-
if (member.hasPermission(channel, Permission.ADMINISTRATOR))
175-
return true;
176-
return isCommandAllowedInChannel(channel, member, command);
177-
}
178-
179-
private boolean isCommandAllowedInChannel(GuildChannel channel, Member member, Command command)
180-
{
181-
final IntegrationPrivilege commandChannelPermissions = findPrivilege(getCommandPrivileges(command), matchingChannel(channel));
182-
if (commandChannelPermissions != null)
183-
{
184-
if (commandChannelPermissions.isDisabled())
185-
return false;
186-
return userOrRolePermission(channel, member, command);
187-
}
188-
else
189-
return isCommandAllowedInAllChannels(channel, member, command);
190-
}
191-
192-
private boolean isCommandAllowedInAllChannels(GuildChannel channel, Member member, Command command)
193-
{
194-
final IntegrationPrivilege commandAllChannelsPermissions = findPrivilege(getCommandPrivileges(command), IntegrationPrivilege::targetsAllChannels);
195-
196-
if (commandAllChannelsPermissions != null)
197-
{
198-
if (commandAllChannelsPermissions.isEnabled())
199-
return userOrRolePermission(channel, member, command);
200-
return false;
201-
}
202-
else
203-
return isAppAllowedInChannel(channel, member, command);
204-
}
205-
206-
private boolean userOrRolePermission(GuildChannel channel, Member member, Command command)
207-
{
208-
final List<IntegrationPrivilege> commandPrivileges = getCommandPrivileges(command);
209-
final IntegrationPrivilege commandUserPermissions = findPrivilege(commandPrivileges, matchingMember(member));
210-
if (commandUserPermissions != null)
211-
return commandUserPermissions.isEnabled();
212-
else
213-
{
214-
// If there's a role override, then at least one needs to be enabled
215-
// If there's no role override, check @everyone
216-
final List<IntegrationPrivilege> commandRolePermissionList = member.getRoles().stream()
217-
.map(r -> findPrivilege(commandPrivileges, matchingRole(r)))
218-
.filter(Objects::nonNull)
219-
.collect(Collectors.toList());
220-
if (commandRolePermissionList.isEmpty())
221-
return commandEveryonePermission(channel, member, command);
222-
223-
for (IntegrationPrivilege integrationPrivilege : commandRolePermissionList)
224-
{
225-
if (integrationPrivilege.isEnabled())
226-
return true;
227-
}
228-
return false;
229-
}
230-
}
231-
232-
private boolean commandEveryonePermission(GuildChannel channel, Member member, Command command)
233-
{
234-
final IntegrationPrivilege commandEveryonePermissions = findPrivilege(getCommandPrivileges(command), matchingRole(channel.getGuild().getPublicRole()));
235-
if (commandEveryonePermissions != null)
236-
return commandEveryonePermissions.isEnabled();
237-
return appLevelUserOrRolePermission(channel, member, command);
238-
}
239-
240-
private boolean appLevelUserOrRolePermission(GuildChannel channel, Member member, Command command)
241-
{
242-
final List<IntegrationPrivilege> applicationPrivileges = getApplicationPrivileges();
243-
final IntegrationPrivilege appUserPermissions = findPrivilege(applicationPrivileges, matchingMember(member));
244-
if (appUserPermissions != null)
245-
{
246-
if (appUserPermissions.isEnabled())
247-
return hasDefaultMemberPermissions(channel, member, command);
248-
}
249-
else
250-
{
251-
// If there's a role override, then at least one needs to be enabled
252-
// If there's no role override, check @everyone
253-
final List<IntegrationPrivilege> commandRolePermissionList = member.getRoles().stream()
254-
.map(r -> findPrivilege(applicationPrivileges, matchingRole(r)))
255-
.filter(Objects::nonNull)
256-
.collect(Collectors.toList());
257-
if (commandRolePermissionList.isEmpty())
258-
return isAppAllowingEveryone(channel, member, command);
259-
260-
for (IntegrationPrivilege integrationPrivilege : commandRolePermissionList)
261-
{
262-
if (integrationPrivilege.isEnabled())
263-
return hasDefaultMemberPermissions(channel, member, command);
264-
}
265-
}
266-
return false;
267-
}
268-
269-
private boolean isAppAllowingEveryone(GuildChannel channel, Member member, Command command)
270-
{
271-
final IntegrationPrivilege commandEveryonePermissions = findPrivilege(getCommandPrivileges(command), matchingRole(channel.getGuild().getPublicRole()));
272-
if (commandEveryonePermissions != null)
273-
{
274-
if (commandEveryonePermissions.isEnabled())
275-
return hasDefaultMemberPermissions(channel, member, command);
276-
return false;
277-
}
278-
return appLevelUserOrRolePermission(channel, member, command);
279-
}
280-
281-
private boolean hasDefaultMemberPermissions(GuildChannel channel, Member member, Command command)
282-
{
283-
final Long rawPermissions = command.getDefaultPermissions().getPermissionsRaw();
284-
// No permissions requires
285-
if (rawPermissions == null)
286-
return true;
287-
// Admins only, already checked in [[PrivilegeConfig#canMemberRun]]
288-
if (rawPermissions == 0)
289-
return false;
290-
return ((PermissionUtil.getEffectivePermission(channel, member) & rawPermissions) == rawPermissions);
291-
}
292-
293-
private boolean isAppAllowedInChannel(GuildChannel channel, Member member, Command command)
294-
{
295-
final IntegrationPrivilege appChannelPermissions = findPrivilege(getApplicationPrivileges(), matchingChannel(channel));
296-
if (appChannelPermissions != null)
297-
{
298-
if (appChannelPermissions.isEnabled())
299-
return userOrRolePermission(channel, member, command);
300-
return false;
301-
}
302-
else
303-
return isAppAllowedInAllChannels(channel, member, command);
304-
}
305-
306-
private boolean isAppAllowedInAllChannels(GuildChannel channel, Member member, Command command)
307-
{
308-
final IntegrationPrivilege appChannelPermissions = findPrivilege(getApplicationPrivileges(), IntegrationPrivilege::targetsAllChannels);
309-
if (appChannelPermissions != null)
310-
{
311-
if (appChannelPermissions.isEnabled())
312-
return userOrRolePermission(channel, member, command);
313-
return false;
314-
}
315-
else
316-
return userOrRolePermission(channel, member, command);
317-
}
318-
319-
@Nullable
320-
private static IntegrationPrivilege findPrivilege(@Nullable Collection<IntegrationPrivilege> privileges, @Nonnull Predicate<IntegrationPrivilege> predicate)
321-
{
322-
if (privileges == null)
323-
return null;
324-
return privileges.stream()
325-
.filter(predicate)
326-
.findAny()
327-
.orElse(null);
328-
}
329-
330-
@Nonnull
331-
private static Predicate<IntegrationPrivilege> matchingChannel(@Nonnull GuildChannel channel)
332-
{
333-
return p -> p.getType() == IntegrationPrivilege.Type.CHANNEL && p.getIdLong() == channel.getIdLong();
334-
}
335-
336-
@Nonnull
337-
private static Predicate<IntegrationPrivilege> matchingMember(@Nonnull Member member)
338-
{
339-
return p -> p.getType() == IntegrationPrivilege.Type.USER && p.getIdLong() == member.getIdLong();
340-
}
341-
342-
@Nonnull
343-
private static Predicate<IntegrationPrivilege> matchingRole(@Nonnull Role role)
344-
{
345-
return p -> p.getType() == IntegrationPrivilege.Type.ROLE && p.getIdLong() == role.getIdLong();
173+
return PrivilegeHelper.canMemberRun(this, channel, member, command);
346174
}
347175
}

‎src/main/java/net/dv8tion/jda/internal/utils/interactions/commands/AppLevelChannelPermissionChecks.java

+55
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
/*
2+
* Copyright 2015 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package net.dv8tion.jda.internal.utils.interactions.commands;
18+
19+
import net.dv8tion.jda.api.entities.Member;
20+
import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
21+
import net.dv8tion.jda.api.interactions.commands.Command;
22+
import net.dv8tion.jda.api.interactions.commands.PrivilegeConfig;
23+
import net.dv8tion.jda.api.interactions.commands.privileges.IntegrationPrivilege;
24+
25+
import static net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper.findPrivilege;
26+
import static net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper.matchingChannel;
27+
28+
public class AppLevelChannelPermissionChecks
29+
{
30+
public static boolean canMemberRun(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
31+
{
32+
final IntegrationPrivilege appChannelPermissions = findPrivilege(config.getApplicationPrivileges(), matchingChannel(channel));
33+
if (appChannelPermissions != null)
34+
{
35+
if (appChannelPermissions.isEnabled())
36+
return CommandLevelUserOrRolePermissionChecks.canMemberRun(config, channel, member, command);
37+
return false;
38+
}
39+
else
40+
return isAppAllowedInAllChannels(config, channel, member, command);
41+
}
42+
43+
private static boolean isAppAllowedInAllChannels(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
44+
{
45+
final IntegrationPrivilege appChannelPermissions = findPrivilege(config.getApplicationPrivileges(), IntegrationPrivilege::targetsAllChannels);
46+
if (appChannelPermissions != null)
47+
{
48+
if (appChannelPermissions.isEnabled())
49+
return CommandLevelUserOrRolePermissionChecks.canMemberRun(config, channel, member, command);
50+
return false;
51+
}
52+
else
53+
return CommandLevelUserOrRolePermissionChecks.canMemberRun(config, channel, member, command);
54+
}
55+
}

‎src/main/java/net/dv8tion/jda/internal/utils/interactions/commands/AppLevelUserOrRolePermissionChecks.java

+73
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
/*
2+
* Copyright 2015 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package net.dv8tion.jda.internal.utils.interactions.commands;
18+
19+
import net.dv8tion.jda.api.entities.Member;
20+
import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
21+
import net.dv8tion.jda.api.interactions.commands.Command;
22+
import net.dv8tion.jda.api.interactions.commands.PrivilegeConfig;
23+
import net.dv8tion.jda.api.interactions.commands.privileges.IntegrationPrivilege;
24+
25+
import java.util.List;
26+
import java.util.Objects;
27+
import java.util.stream.Collectors;
28+
29+
import static net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper.*;
30+
31+
public class AppLevelUserOrRolePermissionChecks
32+
{
33+
public static boolean canMemberRun(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
34+
{
35+
final List<IntegrationPrivilege> applicationPrivileges = config.getApplicationPrivileges();
36+
final IntegrationPrivilege appUserPermissions = findPrivilege(applicationPrivileges, matchingMember(member));
37+
if (appUserPermissions != null)
38+
{
39+
if (appUserPermissions.isEnabled())
40+
return DefaultMemberPermissionsChecks.canMemberRun(channel, member, command);
41+
}
42+
else
43+
{
44+
// If there's a role override, then at least one needs to be enabled
45+
// If there's no role override, check @everyone
46+
final List<IntegrationPrivilege> commandRolePermissionList = member.getRoles().stream()
47+
.map(r -> findPrivilege(applicationPrivileges, matchingRole(r)))
48+
.filter(Objects::nonNull)
49+
.collect(Collectors.toList());
50+
if (commandRolePermissionList.isEmpty())
51+
return isAppAllowingEveryone(config, channel, member, command);
52+
53+
for (IntegrationPrivilege integrationPrivilege : commandRolePermissionList)
54+
{
55+
if (integrationPrivilege.isEnabled())
56+
return DefaultMemberPermissionsChecks.canMemberRun(channel, member, command);
57+
}
58+
}
59+
return false;
60+
}
61+
62+
private static boolean isAppAllowingEveryone(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
63+
{
64+
final IntegrationPrivilege commandEveryonePermissions = findPrivilege(config.getApplicationPrivileges(), matchingRole(channel.getGuild().getPublicRole()));
65+
if (commandEveryonePermissions != null)
66+
{
67+
if (commandEveryonePermissions.isEnabled())
68+
return DefaultMemberPermissionsChecks.canMemberRun(channel, member, command);
69+
return false;
70+
}
71+
return DefaultMemberPermissionsChecks.canMemberRun(channel, member, command);
72+
}
73+
}

‎src/main/java/net/dv8tion/jda/internal/utils/interactions/commands/CommandLevelChannelPermissionChecks.java

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
/*
2+
* Copyright 2015 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package net.dv8tion.jda.internal.utils.interactions.commands;
18+
19+
import net.dv8tion.jda.api.entities.Member;
20+
import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
21+
import net.dv8tion.jda.api.interactions.commands.Command;
22+
import net.dv8tion.jda.api.interactions.commands.PrivilegeConfig;
23+
import net.dv8tion.jda.api.interactions.commands.privileges.IntegrationPrivilege;
24+
25+
import static net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper.findPrivilege;
26+
import static net.dv8tion.jda.internal.utils.interactions.commands.PrivilegeHelper.matchingChannel;
27+
28+
public class CommandLevelChannelPermissionChecks
29+
{
30+
public static boolean canMemberRun(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
31+
{
32+
final IntegrationPrivilege commandChannelPermissions = findPrivilege(config.getCommandPrivileges(command), matchingChannel(channel));
33+
if (commandChannelPermissions != null)
34+
{
35+
if (commandChannelPermissions.isDisabled())
36+
return false;
37+
return CommandLevelUserOrRolePermissionChecks.canMemberRun(config, channel, member, command);
38+
}
39+
else
40+
return isCommandAllowedInAllChannels(config, channel, member, command);
41+
}
42+
43+
private static boolean isCommandAllowedInAllChannels(PrivilegeConfig config, GuildChannel channel, Member member, Command command)
44+
{
45+
final IntegrationPrivilege commandAllChannelsPermissions = findPrivilege(config.getCommandPrivileges(command), IntegrationPrivilege::targetsAllChannels);
46+
47+
if (commandAllChannelsPermissions != null)
48+
{
49+
if (commandAllChannelsPermissions.isEnabled())
50+
return CommandLevelUserOrRolePermissionChecks.canMemberRun(config, channel, member, command);
51+
return false;
52+
}
53+
else
54+
return AppLevelChannelPermissionChecks.canMemberRun(config, channel, member, command);
55+
}
56+
}

0 commit comments

Comments
 (0)