373 lines
17 KiB
Java
Executable File
373 lines
17 KiB
Java
Executable File
package com.alttd.velocitychat.handlers;
|
|
|
|
import com.alttd.chat.config.Config;
|
|
import com.alttd.chat.database.Queries;
|
|
import com.alttd.chat.managers.ChatUserManager;
|
|
import com.alttd.chat.managers.PartyManager;
|
|
import com.alttd.chat.managers.RegexManager;
|
|
import com.alttd.chat.objects.*;
|
|
import com.alttd.chat.objects.chat_log.ChatLogHandler;
|
|
import com.alttd.chat.objects.chat_log.ChatLogType;
|
|
import com.alttd.chat.util.ALogger;
|
|
import com.alttd.chat.util.Utility;
|
|
import com.alttd.velocitychat.VelocityChat;
|
|
import com.google.common.io.ByteArrayDataOutput;
|
|
import com.google.common.io.ByteStreams;
|
|
import com.velocitypowered.api.command.CommandSource;
|
|
import com.velocitypowered.api.proxy.Player;
|
|
import com.velocitypowered.api.proxy.ServerConnection;
|
|
import net.kyori.adventure.text.Component;
|
|
import net.kyori.adventure.text.ComponentLike;
|
|
import net.kyori.adventure.text.TextReplacementConfig;
|
|
import net.kyori.adventure.text.minimessage.MiniMessage;
|
|
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
|
|
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
|
|
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
|
|
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
import java.time.Duration;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.Optional;
|
|
import java.util.UUID;
|
|
|
|
public class ChatHandler {
|
|
|
|
private final ChatLogHandler chatLogHandler;
|
|
|
|
public ChatHandler(ChatLogHandler chatLogHandler) {
|
|
this.chatLogHandler = chatLogHandler;
|
|
}
|
|
|
|
public void privateMessage(String sender, String target, String message) {
|
|
UUID uuid = UUID.fromString(sender);
|
|
ChatUser senderUser = ChatUserManager.getChatUser(uuid);
|
|
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
|
|
if (optionalPlayer.isEmpty()) {
|
|
return;
|
|
}
|
|
Player player = optionalPlayer.get();
|
|
|
|
Optional<Player> optionalPlayer2 = VelocityChat.getPlugin().getProxy().getPlayer(target);
|
|
if (optionalPlayer2.isEmpty()) {
|
|
return;
|
|
}
|
|
Player player2 = optionalPlayer2.get();
|
|
ChatUser targetUser = ChatUserManager.getChatUser(player2.getUniqueId());
|
|
|
|
TagResolver Placeholders = TagResolver.resolver(
|
|
Placeholder.component("sender", senderUser.getDisplayName()),
|
|
Placeholder.unparsed("sendername", player.getUsername()),
|
|
Placeholder.component("receiver", targetUser.getDisplayName()),
|
|
Placeholder.unparsed("receivername", player2.getUsername()),
|
|
Placeholder.component("message", GsonComponentSerializer.gson().deserialize(message)),
|
|
Placeholder.unparsed("server",
|
|
player.getCurrentServer().isPresent() ? player.getCurrentServer()
|
|
.get()
|
|
.getServerInfo()
|
|
.getName() : "Altitude"
|
|
)
|
|
);
|
|
|
|
ServerConnection serverConnection;
|
|
//Log handled on receiving server since it is only received on one server and that's where the ignore check happens
|
|
if (player.getCurrentServer().isPresent() && player2.getCurrentServer().isPresent()) {
|
|
// redirect to the sender
|
|
serverConnection = player.getCurrentServer().get();
|
|
Component component = Utility.parseMiniMessage(Config.MESSAGESENDER
|
|
.replaceAll("<sendername>", player.getUsername())
|
|
.replaceAll("<receivername>", player2.getUsername()), Placeholders
|
|
).asComponent();
|
|
ByteArrayDataOutput buf = ByteStreams.newDataOutput();
|
|
buf.writeUTF("privatemessageout");
|
|
buf.writeUTF(player.getUniqueId().toString());
|
|
buf.writeUTF(player2.getUsername());
|
|
buf.writeUTF(GsonComponentSerializer.gson().serialize(component));
|
|
buf.writeUTF(player2.getUniqueId().toString());
|
|
serverConnection.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), buf.toByteArray());
|
|
|
|
//redirect to the receiver
|
|
serverConnection = player2.getCurrentServer().get();
|
|
component = Utility.parseMiniMessage(Config.MESSAGERECIEVER
|
|
.replaceAll("<sendername>", player.getUsername())
|
|
.replaceAll("<receivername>", player2.getUsername()), Placeholders
|
|
).asComponent();
|
|
buf = ByteStreams.newDataOutput();
|
|
buf.writeUTF("privatemessagein");
|
|
buf.writeUTF(player2.getUniqueId().toString());
|
|
buf.writeUTF(player.getUsername());
|
|
buf.writeUTF(GsonComponentSerializer.gson().serialize(component));
|
|
buf.writeUTF(player.getUniqueId().toString());
|
|
serverConnection.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), buf.toByteArray());
|
|
}
|
|
|
|
}
|
|
|
|
public static void sendBlockedNotification(String prefix, Player player, String input, String target, ServerConnection serverConnection) {
|
|
TagResolver Placeholders = TagResolver.resolver(
|
|
Placeholder.unparsed("prefix", prefix),
|
|
Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getUsername())),
|
|
Placeholder.unparsed("target", (target.isEmpty() ? " tried to say: " : " -> " + target + ": ")),
|
|
Placeholder.unparsed("input", input)
|
|
);
|
|
ComponentLike blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, Placeholders);
|
|
|
|
serverConnection.getServer().getPlayersConnected().forEach(pl -> {
|
|
if (pl.hasPermission("chat.alert-blocked")) {
|
|
pl.sendMessage(blockedNotification);
|
|
}
|
|
});
|
|
player.sendMessage(Utility.parseMiniMessage("<red>The language you used in your message is not allowed, " +
|
|
"this constitutes as your only warning. Any further attempts at bypassing the filter will result in staff intervention.</red>"));
|
|
}
|
|
|
|
public void sendPartyMessage(Party party, Component message, @Nullable List<UUID> ignoredPlayers) {
|
|
VelocityChat.getPlugin().getProxy().getAllPlayers().stream()
|
|
.filter(pl -> {
|
|
UUID uuid = pl.getUniqueId();
|
|
if (ignoredPlayers != null && ignoredPlayers.contains(uuid)) {
|
|
return false;
|
|
}
|
|
return party.getPartyUsers().stream().anyMatch(pu -> pu.getUuid().equals(uuid));
|
|
}).forEach(pl -> {
|
|
pl.sendMessage(message);
|
|
// TODO forward sound to backend server.
|
|
// https://canary.discord.com/channels/514920774923059209/1020498592219271189
|
|
});
|
|
}
|
|
|
|
public void sendPartyMessage(UUID uuid, String message, Component item, ServerConnection serverConnection) {
|
|
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
|
|
if (optionalPlayer.isEmpty()) {
|
|
return;
|
|
}
|
|
Player player = optionalPlayer.get();
|
|
ChatUser user = ChatUserManager.getChatUser(uuid);
|
|
Party party = PartyManager.getParty(user.getPartyId());
|
|
if (party == null) {
|
|
player.sendMessage(Utility.parseMiniMessage(Config.NOT_IN_A_PARTY));
|
|
return;
|
|
}
|
|
ComponentLike senderName = user.getDisplayName();
|
|
|
|
TagResolver placeholders = TagResolver.resolver(
|
|
Placeholder.component("sender", senderName),
|
|
Placeholder.component("sendername", senderName),
|
|
Placeholder.unparsed("partyname", party.getPartyName()),
|
|
Placeholder.component("message", parseMessageContent(player, message)),
|
|
Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName())
|
|
);
|
|
|
|
Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, placeholders).asComponent()
|
|
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(item).build());
|
|
|
|
ModifiableString modifiableString = new ModifiableString(partyMessage);
|
|
if (!RegexManager.filterText(player.getUsername(), uuid, modifiableString, "party")) {
|
|
sendBlockedNotification("Party Language", player, message, "", serverConnection);
|
|
return; // the message was blocked
|
|
}
|
|
|
|
partyMessage = modifiableString.component();
|
|
|
|
sendPartyMessage(party, partyMessage, user.getIgnoredBy());
|
|
|
|
chatLogHandler.addChatLog(uuid,
|
|
serverConnection.getServer().getServerInfo().getName(),
|
|
PlainTextComponentSerializer.plainText().serialize(partyMessage),
|
|
ChatLogType.PARTY,
|
|
String.valueOf(party.getPartyId()),
|
|
null,
|
|
partyMessage,
|
|
false
|
|
);
|
|
|
|
ComponentLike spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, placeholders);
|
|
for (Player pl : serverConnection.getServer().getPlayersConnected()) {
|
|
if (pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) {
|
|
pl.sendMessage(spyMessage);
|
|
}
|
|
}
|
|
ALogger.info(PlainTextComponentSerializer.plainText().serialize(partyMessage));
|
|
}
|
|
|
|
public void globalAdminChat(String message) {
|
|
Component component = GsonComponentSerializer.gson().deserialize(message);
|
|
|
|
VelocityChat.getPlugin().getProxy().getAllPlayers()
|
|
.stream()
|
|
.filter(target -> target.hasPermission("command.chat.globaladminchat"))
|
|
.forEach(target -> target.sendMessage(component));
|
|
|
|
chatLogHandler.addChatLog(
|
|
new UUID(0, 0), //No origin uuid for GAC
|
|
"GAC", //No server for GAC
|
|
PlainTextComponentSerializer.plainText().serialize(component),
|
|
ChatLogType.GAC,
|
|
null,
|
|
null,
|
|
component,
|
|
false
|
|
);
|
|
}
|
|
|
|
public void globalAdminChat(CommandSource commandSource, String message) {
|
|
ComponentLike senderName = Component.text(Config.CONSOLENAME);
|
|
String serverName = "Altitude";
|
|
if (commandSource instanceof Player sender) {
|
|
ChatUser user = ChatUserManager.getChatUser(sender.getUniqueId());
|
|
if (user == null) {
|
|
return;
|
|
}
|
|
senderName = user.getDisplayName();
|
|
serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer()
|
|
.get()
|
|
.getServerInfo()
|
|
.getName() : "Altitude";
|
|
}
|
|
|
|
TagResolver Placeholders = TagResolver.resolver(
|
|
Placeholder.component("message", parseMessageContent(commandSource, message)),
|
|
Placeholder.component("sender", senderName),
|
|
Placeholder.unparsed("server", serverName)
|
|
);
|
|
|
|
ComponentLike component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders);
|
|
|
|
VelocityChat.getPlugin().getProxy().getAllPlayers()
|
|
.stream()
|
|
.filter(target -> target.hasPermission("command.chat.globaladminchat"))
|
|
.forEach(target -> target.sendMessage(component));
|
|
}
|
|
|
|
public void sendMail(CommandSource commandSource, String recipient, String message) {
|
|
UUID uuid = Config.CONSOLEUUID;
|
|
String senderName = Config.CONSOLENAME;
|
|
UUID targetUUID;
|
|
if (commandSource instanceof Player player) {
|
|
uuid = player.getUniqueId();
|
|
senderName = player.getUsername();
|
|
}
|
|
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(recipient);
|
|
if (optionalPlayer.isEmpty()) {
|
|
targetUUID = ServerHandler.getPlayerUUID(recipient);
|
|
if (targetUUID == null) {
|
|
commandSource.sendMessage(Utility.parseMiniMessage(
|
|
"<red>A player with this name hasn't logged in recently.")); // TOOD load from config
|
|
return;
|
|
}
|
|
} else {
|
|
targetUUID = optionalPlayer.get().getUniqueId();
|
|
}
|
|
Mail mail = new Mail(targetUUID, uuid, message);
|
|
ChatUser chatUser = ChatUserManager.getChatUser(targetUUID);
|
|
if (chatUser.getIgnoredPlayers().contains(uuid)) {
|
|
commandSource.sendMessage(Utility.parseMiniMessage("<red>You cannot mail this player</red>"));
|
|
return;
|
|
}
|
|
chatUser.addMail(mail);
|
|
// TODO load from config
|
|
String finalSenderName = senderName;
|
|
optionalPlayer.ifPresent(player -> player.sendMessage(Utility.parseMiniMessage("<yellow>New mail from " + finalSenderName)));
|
|
commandSource.sendMessage(Utility.parseMiniMessage("<yellow>Sent mail to " + recipient + "!"));
|
|
}
|
|
|
|
public void readMail(CommandSource commandSource, String targetPlayer, String senderPlayer) {
|
|
UUID uuid = ServerHandler.getPlayerUUID(targetPlayer);
|
|
if (uuid == null) {
|
|
commandSource.sendMessage(Utility.parseMiniMessage(Config.mailNoUser));
|
|
return;
|
|
}
|
|
|
|
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
|
|
if (senderPlayer == null) {
|
|
commandSource.sendMessage(parseMails(chatUser.getMails(), false));
|
|
}
|
|
|
|
UUID sender = ServerHandler.getPlayerUUID(senderPlayer);
|
|
if (sender == null) {
|
|
commandSource.sendMessage(Utility.parseMiniMessage(Config.mailNoUser));
|
|
return;
|
|
}
|
|
|
|
List<Mail> mails = chatUser.getMails().stream()
|
|
.filter(mail -> mail.getSender().equals(sender))
|
|
.toList();
|
|
commandSource.sendMessage(parseMails(mails, false));
|
|
}
|
|
|
|
public void readMail(CommandSource commandSource, boolean unread) {
|
|
if (commandSource instanceof Player player) {
|
|
ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
|
|
commandSource.sendMessage(parseMails(unread ? chatUser.getUnReadMail() : chatUser.getMails(), unread));
|
|
}
|
|
}
|
|
|
|
private Component parseMails(List<Mail> mails, boolean mark) {
|
|
Component component = Utility.parseMiniMessage(Config.mailHeader).asComponent();
|
|
for (Mail mail : mails) {
|
|
if (mail.isUnRead() && mark) {
|
|
mail.setReadTime(System.currentTimeMillis());
|
|
Queries.markMailRead(mail);
|
|
}
|
|
Date date = new Date(mail.getSendTime());
|
|
ChatUser chatUser = ChatUserManager.getChatUser(mail.getSender());
|
|
TagResolver Placeholders = TagResolver.resolver(
|
|
Placeholder.component("staffprefix", chatUser.getStaffPrefix()),
|
|
Placeholder.component("sender", chatUser.getDisplayName()),
|
|
Placeholder.component("message", Utility.parseMiniMessage(mail.getMessage())),
|
|
Placeholder.unparsed("date", date.toString()),
|
|
Placeholder.unparsed("time_ago",
|
|
getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant()))
|
|
)
|
|
);
|
|
ComponentLike mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders);
|
|
component = component.append(Component.newline()).append(mailMessage);
|
|
}
|
|
component = component.append(Component.newline()).append(Utility.parseMiniMessage(Config.mailFooter));
|
|
return component;
|
|
}
|
|
|
|
public void mutePlayer(String uuid, boolean muted) {
|
|
ByteArrayDataOutput buf = ByteStreams.newDataOutput();
|
|
buf.writeUTF("chatpunishments");
|
|
buf.writeUTF(uuid);
|
|
buf.writeBoolean(muted);
|
|
}
|
|
|
|
private String getTimeAgo(Duration duration) {
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
if (duration.toDays() != 0) {
|
|
stringBuilder.append(duration.toDays()).append("d ");
|
|
}
|
|
if (duration.toHoursPart() != 0 || !stringBuilder.isEmpty()) {
|
|
stringBuilder.append(duration.toHoursPart()).append("h ");
|
|
}
|
|
stringBuilder.append(duration.toMinutesPart()).append("m ago");
|
|
return stringBuilder.toString();
|
|
}
|
|
|
|
private Component parseMessageContent(CommandSource source, String rawMessage) {
|
|
TagResolver.Builder tagResolver = TagResolver.builder();
|
|
|
|
Utility.formattingPerms.forEach((perm, pair) -> {
|
|
if (source.hasPermission(perm)) {
|
|
tagResolver.resolver(pair.getX());
|
|
}
|
|
});
|
|
|
|
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
|
|
Component component = miniMessage.deserialize(rawMessage);
|
|
for (ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
|
|
component = component.replaceText(
|
|
TextReplacementConfig.builder()
|
|
.times(Config.EMOTELIMIT)
|
|
.match(chatFilter.getRegex())
|
|
.replacement(chatFilter.getReplacement()).build());
|
|
}
|
|
|
|
return component;
|
|
|
|
}
|
|
}
|