diff --git a/README.md b/README.md index 5344219..0e9c94b 100644 --- a/README.md +++ b/README.md @@ -41,3 +41,24 @@ TelegramChat is a Bukkit plugin compatible with Paper/Spigot versions 1.7 throug ``` + +## Developers +* [Jenkins](https://ci.spaceio.xyz/job/TelegramChat/lastBuild/xyz.spaceio$telegramchat/) latest builds, including unstable ones +* [Repository](https://repo.spaceio.xyz/#browse/browse:maven-snapshots:xyz%2Fspaceio%2Ftelegramchat) + +### API +```xml + + spaceio-repo + https://repo.spaceio.xyz/repository/maven-public/ + + + + + xyz.spaceio + telegramchat + VERSION_HERE-SNAPSHOT + provided + + +``` diff --git a/lib/Chatty.jar b/lib/Chatty.jar new file mode 100644 index 0000000..d01f239 Binary files /dev/null and b/lib/Chatty.jar differ diff --git a/pom.xml b/pom.xml index c68714e..66f3136 100644 --- a/pom.xml +++ b/pom.xml @@ -32,6 +32,33 @@ + + mysql + mysql-connector-java + 8.0.28 + + + org.javassist + javassist + 3.22.0-GA + + + jakarta.xml.bind + jakarta.xml.bind-api + 2.3.2 + + + + + org.glassfish.jaxb + jaxb-runtime + 2.3.2 + + + org.hibernate + hibernate-core + 5.6.7.Final + org.spigotmc spigot-api @@ -49,6 +76,13 @@ 1.7 provided + + com.roufid.tutorials + example-app + 1.0 + system + ${basedir}/lib/Chatty.jar + @@ -71,6 +105,8 @@ plugin.yml config.yml + hikaricp.properties + META-INF/persistence.xml @@ -98,6 +134,47 @@ ${project.build.finalName} + + org.apache.maven.plugins + maven-assembly-plugin + 3.1.1 + + + + jar-with-dependencies + + + + + + make-assembly + package + + single + + + + + + org.apache.maven.plugins + maven-install-plugin + 2.5.2 + + + initialize + + install-file + + + com.roufid.tutorials + example-app + 1.0 + jar + ${basedir}/lib/Chatty.jar + + + + \ No newline at end of file diff --git a/src/main/java/de/Linus122/Telegram/API.java b/src/main/java/de/Linus122/Telegram/API.java deleted file mode 100644 index 3608915..0000000 --- a/src/main/java/de/Linus122/Telegram/API.java +++ /dev/null @@ -1,9 +0,0 @@ -package de.Linus122.Telegram; - -import de.Linus122.TelegramChat.TelegramChat; - -public class API { - public static Telegram getTelegramHook() { - return TelegramChat.telegramHook; - } -} diff --git a/src/main/java/de/Linus122/Telegram/Telegram.java b/src/main/java/de/Linus122/Telegram/Telegram.java index 29f668f..431b51e 100755 --- a/src/main/java/de/Linus122/Telegram/Telegram.java +++ b/src/main/java/de/Linus122/Telegram/Telegram.java @@ -1,5 +1,16 @@ package de.Linus122.Telegram; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import de.Linus122.TelegramChat.TelegramChat; +import de.Linus122.TelegramComponents.Chat; +import de.Linus122.TelegramComponents.ChatMessageToMc; +import de.Linus122.TelegramComponents.ChatMessageToTelegram; +import de.Linus122.TelegramComponents.Update; +import org.bukkit.Bukkit; + import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.DataOutputStream; @@ -11,17 +22,8 @@ import java.net.URLConnection; import java.util.ArrayList; import java.util.List; - -import com.google.gson.Gson; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; - -import de.Linus122.TelegramComponents.ChatMessageToTelegram; -import de.Linus122.TelegramChat.TelegramChat; -import de.Linus122.TelegramComponents.Chat; -import de.Linus122.TelegramComponents.ChatMessageToMc; -import de.Linus122.TelegramComponents.Update; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; public class Telegram { public JsonObject authJson; @@ -38,6 +40,8 @@ public class Telegram { private Gson gson = new Gson(); + private Set sentWarnings = ConcurrentHashMap.newKeySet(); + public void addListener(TelegramActionListener actionListener) { listeners.add(actionListener); } @@ -62,7 +66,7 @@ public boolean reconnect() { } public boolean getUpdate() { - JsonObject up = null; + JsonObject up; try { up = sendGet(String.format(API_URL_GETUPDATES, TelegramChat.getBackend().getToken(), lastUpdate + 1)); } catch (IOException e) { @@ -83,33 +87,12 @@ public boolean getUpdate() { Chat chat = update.getMessage().getChat(); if (chat.isPrivate()) { - // private chat - if (!TelegramChat.getBackend().chat_ids.contains(chat.getId())) - TelegramChat.getBackend().chat_ids.add(chat.getId()); - - if (update.getMessage().getText() != null) { - String text = update.getMessage().getText(); - if (text.length() == 0) - return true; - if (text.equals("/start")) { - if (TelegramChat.getBackend().isFirstUse()) { - TelegramChat.getBackend().setFirstUse(false); - ChatMessageToTelegram chat2 = new ChatMessageToTelegram(); - chat2.chat_id = chat.getId(); - chat2.parse_mode = "Markdown"; - chat2.text = Utils.formatMSG("setup-msg")[0]; - this.sendMsg(chat2); - } - this.sendMsg(chat.getId(), Utils.formatMSG("can-see-but-not-chat")[0]); - } else { - handleUserMessage(text, update); - } - } + // skip } else if (!chat.isPrivate()) { // group chat long id = chat.getId(); - if (!TelegramChat.getBackend().chat_ids.contains(id)) + if (!TelegramChat.getBackend().chat_ids.contains(id) && TelegramChat.getBackend().chat_ids.size() < 1) TelegramChat.getBackend().chat_ids.add(id); if (update.getMessage().getText() != null) { @@ -127,14 +110,14 @@ public boolean getUpdate() { public void handleUserMessage(String text, Update update) { Chat chat = update.getMessage().getChat(); - long user_id = update.getMessage().getFrom().getId(); + long chatId = update.getMessage().getFrom().getId(); if (TelegramChat.getBackend().getLinkCodes().containsKey(text)) { // LINK - TelegramChat.link(TelegramChat.getBackend().getUUIDFromLinkCode(text), user_id); + TelegramChat.link(TelegramChat.getBackend().getUUIDFromLinkCode(text), chatId); TelegramChat.getBackend().removeLinkCode(text); - } else if (TelegramChat.getBackend().getLinkedChats().containsKey(user_id)) { + } else if (TelegramChat.getBackend().containsChatId(chatId)) { ChatMessageToMc chatMsg = new ChatMessageToMc( - TelegramChat.getBackend().getUUIDFromUserID(user_id), text, chat.getId()); + TelegramChat.getBackend().getUUIDFromUserID(chatId), text, chat.getId()); for (TelegramActionListener actionListener : listeners) { actionListener.onSendToMinecraft(chatMsg); @@ -144,7 +127,10 @@ public void handleUserMessage(String text, Update update) { TelegramChat.sendToMC(chatMsg); } } else { - this.sendMsg(chat.getId(), Utils.formatMSG("need-to-link")[0]); + if (!sentWarnings.contains(chat.getId())) { + this.sendMsg(chat.getId(), Utils.formatMSG("need-to-link")[0]); + sentWarnings.add(chat.getId()); + } } } @@ -166,15 +152,12 @@ public void sendMsg(ChatMessageToTelegram chat) { } public void sendAll(final ChatMessageToTelegram chat) { - new Thread(new Runnable() { - public void run() { - for (long id : TelegramChat.getBackend().chat_ids) { - chat.chat_id = id; - // post("sendMessage", gson.toJson(chat, Chat.class)); - sendMsg(chat); - } + Bukkit.getScheduler().runTaskAsynchronously(TelegramChat.getInstance(), () -> { + for (long id : TelegramChat.getBackend().chat_ids) { + chat.chat_id = id; + sendMsg(chat); } - }).start(); + }); } public void post(String method, String json) { diff --git a/src/main/java/de/Linus122/TelegramChat/Data.java b/src/main/java/de/Linus122/TelegramChat/Data.java index 09a6019..8872269 100755 --- a/src/main/java/de/Linus122/TelegramChat/Data.java +++ b/src/main/java/de/Linus122/TelegramChat/Data.java @@ -1,9 +1,12 @@ package de.Linus122.TelegramChat; -import java.util.ArrayList; +import de.Linus122.entity.User; +import de.Linus122.repository.UserRepository; + import java.util.HashMap; import java.util.List; import java.util.UUID; +import java.util.concurrent.CopyOnWriteArrayList; public class Data { private String token = ""; @@ -14,10 +17,10 @@ public class Data { // Token : Player ID private HashMap linkCodes = new HashMap(); - public List chat_ids = new ArrayList(); + public List chat_ids = new CopyOnWriteArrayList<>(); private boolean firstUse = true; - + public String getToken() { return token; @@ -61,7 +64,21 @@ public void setFirstUse(boolean firstUse) { } public void addChatPlayerLink(long chatID, UUID player) { - linkedChats.put(chatID, player); + final User toUpdate = UserRepository.getInstance().readByPlayerId(player.toString()) + .orElseGet(() -> { + final User user = new User(); + user.setChatId(chatID); + user.setPlayerId(player.toString()); + return user; + }); + toUpdate.setChatId(chatID); + UserRepository.getInstance().update(toUpdate); + } + + public boolean containsChatId(long chatId) { + return UserRepository.getInstance() + .readByChatId(chatId) + .isPresent(); } public void addLinkCode(String code, UUID player) { @@ -77,7 +94,13 @@ public void removeLinkCode(String code) { } public UUID getUUIDFromUserID(long userID) { - return linkedChats.get(userID); + return UserRepository.getInstance() + .readByChatId(userID) + .map(User::getPlayerId) + .map(UUID::fromString) + .orElseThrow(() -> new IllegalArgumentException(String.format("Chat with id %s not found", userID))); } + + } diff --git a/src/main/java/de/Linus122/TelegramChat/LinkTelegramCmd.java b/src/main/java/de/Linus122/TelegramChat/LinkTelegramCmd.java index 68ca940..6b379a4 100755 --- a/src/main/java/de/Linus122/TelegramChat/LinkTelegramCmd.java +++ b/src/main/java/de/Linus122/TelegramChat/LinkTelegramCmd.java @@ -1,14 +1,11 @@ package de.Linus122.TelegramChat; -import java.io.IOException; - +import de.Linus122.Telegram.Utils; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; -import de.Linus122.Telegram.Utils; - public class LinkTelegramCmd implements CommandExecutor { @Override @@ -30,9 +27,7 @@ public boolean onCommand(CommandSender cs, Command arg1, String arg2, String[] a String token = TelegramChat.generateLinkToken(); TelegramChat.getBackend().addLinkCode(token, ((Player) cs).getUniqueId()); - cs.sendMessage(Utils.formatMSG("get-token", - TelegramChat.telegramHook.authJson.getAsJsonObject("result").get("username").getAsString(), - TelegramChat.telegramHook.authJson.getAsJsonObject("result").get("username").getAsString(), token)); + cs.sendMessage(Utils.formatMSG("get-token", token)); return true; } diff --git a/src/main/java/de/Linus122/TelegramChat/TelegramChat.java b/src/main/java/de/Linus122/TelegramChat/TelegramChat.java index 8aabc6c..b0760e1 100755 --- a/src/main/java/de/Linus122/TelegramChat/TelegramChat.java +++ b/src/main/java/de/Linus122/TelegramChat/TelegramChat.java @@ -1,46 +1,45 @@ package de.Linus122.TelegramChat; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileReader; -import java.io.FileWriter; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.util.ArrayList; -import java.util.List; -import java.util.Random; -import java.util.UUID; -import java.util.logging.Level; - +import com.google.gson.Gson; +import de.Linus122.Handlers.BanHandler; import de.Linus122.Handlers.VanishHandler; +import de.Linus122.Metrics.Metrics; +import de.Linus122.Telegram.Telegram; +import de.Linus122.Telegram.Utils; +import de.Linus122.TelegramComponents.Chat; +import de.Linus122.TelegramComponents.ChatMessageToMc; +import de.Linus122.TelegramComponents.ChatMessageToTelegram; +import de.Linus122.entity.User; +import de.Linus122.handler.ChattyEventsHandler; +import de.Linus122.repository.UserRepository; import de.myzelyam.api.vanish.VanishAPI; import org.bukkit.Bukkit; -import org.bukkit.OfflinePlayer; import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.entity.PlayerDeathEvent; -import org.bukkit.event.player.AsyncPlayerChatEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.java.JavaPlugin; -import com.google.gson.Gson; - -import de.Linus122.Handlers.BanHandler; -import de.Linus122.Handlers.CommandHandler; -import de.Linus122.Metrics.Metrics; -import de.Linus122.Telegram.Telegram; -import de.Linus122.Telegram.Utils; -import de.Linus122.TelegramComponents.Chat; -import de.Linus122.TelegramComponents.ChatMessageToMc; -import de.Linus122.TelegramComponents.ChatMessageToTelegram; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.util.Collection; +import java.util.Random; +import java.util.Set; +import java.util.UUID; +import java.util.logging.Level; +import java.util.stream.Collectors; public class TelegramChat extends JavaPlugin implements Listener { - private static File datad = new File("plugins/TelegramChat/data.json"); + private static final File datad = new File("plugins/TelegramChat/data.json"); private static FileConfiguration cfg; - - private static Data data = new Data(); + private static Data data; public static Telegram telegramHook; private static TelegramChat instance; private static boolean isSuperVanish; @@ -54,6 +53,8 @@ public void onEnable() { Bukkit.getPluginCommand("telegram").setExecutor(new TelegramCmd()); Bukkit.getPluginCommand("linktelegram").setExecutor(new LinkTelegramCmd()); + Bukkit.getPluginCommand("tgon").setExecutor(new TgOnCmd()); + Bukkit.getPluginCommand("tgoff").setExecutor(new TgOffCmd()); Bukkit.getPluginManager().registerEvents(this, this); if (Bukkit.getPluginManager().isPluginEnabled("SuperVanish") || Bukkit.getPluginManager().isPluginEnabled("PremiumVanish")) { @@ -61,6 +62,10 @@ public void onEnable() { Bukkit.getPluginManager().registerEvents(new VanishHandler(), this); } + if (Bukkit.getPluginManager().isPluginEnabled("Chatty")) { + Bukkit.getPluginManager().registerEvents(new ChattyEventsHandler(this), this); + } + File dir = new File("plugins/TelegramChat/"); dir.mkdir(); data = new Data(); @@ -74,7 +79,7 @@ public void onEnable() { sb.append((char) c); } - data = (Data) gson.fromJson(sb.toString(), Data.class); + data = gson.fromJson(sb.toString(), Data.class); fileReader.close(); } catch (Exception e) { @@ -83,7 +88,7 @@ public void onEnable() { FileInputStream fin = new FileInputStream(datad); ObjectInputStream ois = new ObjectInputStream(fin); - data = (Data) gson.fromJson((String) ois.readObject(), Data.class); + data = gson.fromJson((String) ois.readObject(), Data.class); ois.close(); fin.close(); } catch (Exception e2) { @@ -104,14 +109,10 @@ public void onEnable() { // telegramHook.addListener(new CommandHandler(telegramHook, this)); Bukkit.getScheduler().runTaskTimerAsynchronously(this, () -> { - boolean connectionLost = false; - if (connectionLost) { - boolean success = telegramHook.reconnect(); - if (success) - connectionLost = false; - } if (telegramHook.connected) { - connectionLost = !telegramHook.getUpdate(); + telegramHook.getUpdate(); + } else { + telegramHook.reconnect(); } }, 10L, 10L); @@ -150,30 +151,44 @@ public static void sendToMC(ChatMessageToMc chatMsg) { } private static void sendToMC(UUID uuid, String msg, long sender_chat) { - OfflinePlayer op = Bukkit.getOfflinePlayer(uuid); - List recievers = new ArrayList(); - recievers.addAll(TelegramChat.data.chat_ids); - recievers.remove((Object) sender_chat); - String msgF = Utils.formatMSG("general-message-to-mc", op.getName(), msg)[0]; - for (long id : recievers) { - telegramHook.sendMsg(id, msgF.replaceAll("§.", "")); - } - Bukkit.broadcastMessage(msgF.replace("&", "§")); - + Bukkit.getScheduler().runTask(instance, () -> { + final String name = Bukkit.getOfflinePlayer(uuid).getName(); + final String msgF = Utils.formatMSG("general-message-to-mc", name, msg)[0]; + final Collection onlinePlayers = Bukkit.getOnlinePlayers(); + final Set ids = onlinePlayers.stream() + .map(Player::getUniqueId) + .map(UUID::toString) + .collect(Collectors.toSet()); + + Bukkit.getScheduler().runTaskAsynchronously(instance, () -> { + final Set users = UserRepository.getInstance() + .findAllMsgOnUsersAmongOnlinePlayers(ids).stream() + .map(User::getPlayerId) + .collect(Collectors.toSet()); + + Bukkit.getScheduler().runTask(instance, () -> { + onlinePlayers.stream() + .filter(player -> !users.contains(player.getUniqueId().toString())) + .forEach(player -> player.sendMessage(msgF)); + }); + }); + }); } public static void link(UUID player, long userID) { TelegramChat.data.addChatPlayerLink(userID, player); - OfflinePlayer p = Bukkit.getOfflinePlayer(player); - telegramHook.sendMsg(userID, "Success! Linked " + p.getName()); + + Bukkit.getScheduler().runTask(instance, () -> { + String name = Bukkit.getOfflinePlayer(player).getName(); + + Bukkit.getScheduler().runTaskAsynchronously(instance, () -> { + telegramHook.sendMsg(userID, "Success! Linked " + name); + }); + }); } public boolean isChatLinked(Chat chat) { - if(TelegramChat.getBackend().getLinkedChats().containsKey(chat.getId())) { - return true; - } - - return false; + return TelegramChat.getBackend().getLinkedChats().containsKey(chat.getId()); } public static String generateLinkToken() { @@ -240,22 +255,6 @@ public void onQuit(PlayerQuitEvent e) { } } - @EventHandler - public void onChat(AsyncPlayerChatEvent e) { - if (!this.getConfig().getBoolean("enable-chatmessages")) - return; - if (e.isCancelled()) - return; - if (telegramHook.connected) { - ChatMessageToTelegram chat = new ChatMessageToTelegram(); - chat.parse_mode = "Markdown"; - chat.text = Utils - .escape(Utils.formatMSG("general-message-to-telegram", e.getPlayer().getName(), e.getMessage())[0]) - .replaceAll("§.", ""); - telegramHook.sendAll(chat); - } - } - public static TelegramChat getInstance() { return instance; diff --git a/src/main/java/de/Linus122/TelegramChat/TelegramCmd.java b/src/main/java/de/Linus122/TelegramChat/TelegramCmd.java index 8a068c7..a376408 100755 --- a/src/main/java/de/Linus122/TelegramChat/TelegramCmd.java +++ b/src/main/java/de/Linus122/TelegramChat/TelegramCmd.java @@ -20,7 +20,7 @@ public boolean onCommand(CommandSender cs, Command arg1, String arg2, String[] a TelegramChat.initBackend(); } TelegramChat.getBackend().setToken(args[0]); - TelegramChat.save(); +// TelegramChat.save(); boolean success = false; success = TelegramChat.telegramHook.auth(TelegramChat.getBackend().getToken()); diff --git a/src/main/java/de/Linus122/TelegramChat/TgOffCmd.java b/src/main/java/de/Linus122/TelegramChat/TgOffCmd.java new file mode 100644 index 0000000..dda11f7 --- /dev/null +++ b/src/main/java/de/Linus122/TelegramChat/TgOffCmd.java @@ -0,0 +1,47 @@ +package de.Linus122.TelegramChat; + +import de.Linus122.Telegram.Utils; +import de.Linus122.entity.User; +import de.Linus122.repository.UserRepository; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TgOffCmd implements CommandExecutor { + + private final UserRepository userRepository = UserRepository.getInstance(); + + @Override + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (!(sender instanceof Player)) return true; + if (!sender.hasPermission("telegram.linktelegram")) { + sender.sendMessage(Utils.formatMSG("no-permissions")[0]); + return true; + } + if (TelegramChat.getBackend() == null) { + TelegramChat.initBackend(); + } + if (TelegramChat.telegramHook.authJson == null) { + sender.sendMessage(Utils.formatMSG("need-to-add-bot-first")[0]); + return true; + } + final String playerId = ((Player) sender).getUniqueId().toString(); + Bukkit.getScheduler().runTaskAsynchronously(TelegramChat.getInstance(), () -> { + final User user = userRepository.readByPlayerId(playerId) + .orElseGet(() -> { + final User newUser = new User(); + newUser.setPlayerId(playerId); + return newUser; + }); + user.setChatEnabled(false); + UserRepository.getInstance().update(user); + + Bukkit.getScheduler().runTask(TelegramChat.getInstance(), () -> { + sender.sendMessage(Utils.formatMSG("telegram-chat-off")[0]); + }); + }); + return true; + } +} diff --git a/src/main/java/de/Linus122/TelegramChat/TgOnCmd.java b/src/main/java/de/Linus122/TelegramChat/TgOnCmd.java new file mode 100644 index 0000000..536b5d4 --- /dev/null +++ b/src/main/java/de/Linus122/TelegramChat/TgOnCmd.java @@ -0,0 +1,47 @@ +package de.Linus122.TelegramChat; + +import de.Linus122.Telegram.Utils; +import de.Linus122.entity.User; +import de.Linus122.repository.UserRepository; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TgOnCmd implements CommandExecutor { + + private final UserRepository userRepository = UserRepository.getInstance(); + + @Override + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (!(sender instanceof Player)) return true; + if (!sender.hasPermission("telegram.linktelegram")) { + sender.sendMessage(Utils.formatMSG("no-permissions")[0]); + return true; + } + if (TelegramChat.getBackend() == null) { + TelegramChat.initBackend(); + } + if (TelegramChat.telegramHook.authJson == null) { + sender.sendMessage(Utils.formatMSG("need-to-add-bot-first")[0]); + return true; + } + final String playerId = ((Player) sender).getUniqueId().toString(); + Bukkit.getScheduler().runTaskAsynchronously(TelegramChat.getInstance(), () -> { + final User user = userRepository.readByPlayerId(playerId) + .orElseGet(() -> { + final User newUser = new User(); + newUser.setPlayerId(playerId); + return newUser; + }); + user.setChatEnabled(true); + UserRepository.getInstance().update(user); + + Bukkit.getScheduler().runTask(TelegramChat.getInstance(), () -> { + sender.sendMessage(Utils.formatMSG("telegram-chat-off")[0]); + }); + }); + return true; + } +} diff --git a/src/main/java/de/Linus122/entity/User.java b/src/main/java/de/Linus122/entity/User.java new file mode 100644 index 0000000..585ac1f --- /dev/null +++ b/src/main/java/de/Linus122/entity/User.java @@ -0,0 +1,47 @@ +package de.Linus122.entity; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name = "users") +public class User { + + @Id + @Column(name = "player_id", length = 64) + private String playerId; + + @Column(name = "chat_id") + private Long chatId; + + public boolean isChatEnabled() { + return chatEnabled; + } + + public void setChatEnabled(boolean chatEnabled) { + this.chatEnabled = chatEnabled; + } + + @Column(name = "chat_enabled") + private boolean chatEnabled = true; + + + public Long getChatId() { + return chatId; + } + + public void setChatId(Long chatId) { + this.chatId = chatId; + } + + + public String getPlayerId() { + return playerId; + } + + public void setPlayerId(String playerId) { + this.playerId = playerId; + } +} diff --git a/src/main/java/de/Linus122/handler/ChattyEventsHandler.java b/src/main/java/de/Linus122/handler/ChattyEventsHandler.java new file mode 100644 index 0000000..4688c9d --- /dev/null +++ b/src/main/java/de/Linus122/handler/ChattyEventsHandler.java @@ -0,0 +1,53 @@ +package de.Linus122.handler; + +import de.Linus122.Telegram.Utils; +import de.Linus122.TelegramChat.TelegramChat; +import de.Linus122.TelegramComponents.ChatMessageToTelegram; +import de.Linus122.entity.User; +import de.Linus122.repository.UserRepository; +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import ru.mrbrikster.chatty.api.events.ChattyMessageEvent; + +public class ChattyEventsHandler implements Listener { + + private final TelegramChat telegramChat; + + public ChattyEventsHandler(TelegramChat telegramChat) { + this.telegramChat = telegramChat; + } + + @EventHandler + public void handleChattyMessageEvent(ChattyMessageEvent e) { + if (!telegramChat.getConfig().getBoolean("enable-chatmessages")) + return; + if (!TelegramChat.telegramHook.connected) { + return; + } + if (!e.getChat().getName().equalsIgnoreCase("global")) { + return; + } + final String playerId = e.getPlayer().getUniqueId().toString(); + Bukkit.getScheduler().runTaskAsynchronously(TelegramChat.getInstance(), () -> { + final boolean chatEnabled = UserRepository.getInstance() + .readByPlayerId(playerId) + .map(User::isChatEnabled) + .orElse(Boolean.TRUE); + + if (!chatEnabled) { + return; + } + + ChatMessageToTelegram chat = new ChatMessageToTelegram(); + chat.parse_mode = "Markdown"; + chat.text = Utils + .escape(Utils.formatMSG("general-message-to-telegram", e.getPlayer().getName(), e.getMessage())[0]) + .replaceAll("§.", ""); + TelegramChat.telegramHook.sendAll(chat); + }); + } + + + +} diff --git a/src/main/java/de/Linus122/repository/UserRepository.java b/src/main/java/de/Linus122/repository/UserRepository.java new file mode 100644 index 0000000..f08e9d7 --- /dev/null +++ b/src/main/java/de/Linus122/repository/UserRepository.java @@ -0,0 +1,96 @@ +package de.Linus122.repository; + +import de.Linus122.TelegramChat.TelegramChat; +import de.Linus122.entity.User; + +import javax.persistence.EntityExistsException; +import javax.persistence.EntityManager; +import javax.persistence.NoResultException; +import javax.persistence.Persistence; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +public class UserRepository { + + private static UserRepository INSTANCE; + + + public synchronized static UserRepository getInstance() { + if (INSTANCE == null) { + Thread.currentThread().setContextClassLoader(TelegramChat.getInstance().getClass().getClassLoader()); + final EntityManager entityManager = Persistence.createEntityManagerFactory("persistence-unit") + .createEntityManager(); + INSTANCE = new UserRepository(entityManager); + } + return INSTANCE; + } + + private EntityManager em; + + public UserRepository(EntityManager em) { + this.em = em; + } + + public Optional create(User person) { + try { + em.getTransaction().begin(); + em.persist(person); + em.flush(); + } catch (EntityExistsException e) { + em.getTransaction().rollback(); + return Optional.of(person); + } + em.getTransaction().commit(); + return Optional.of(person); + + } + + public List findAllMsgOnUsersAmongOnlinePlayers(Set onlinePlayers) { + try { + em.getTransaction().begin(); + return em.createQuery("select u from User u where u.playerId in (:ids) and u.chatEnabled = false") + .setParameter("ids", onlinePlayers) + .getResultList(); + } finally { + em.getTransaction().commit(); + } + } + + public Optional readByChatId(Long id) { + try { + em.getTransaction().begin(); + User user = em.createQuery("select u from User u where u.chatId = :chatId", User.class) + .setParameter("chatId", id) + .getSingleResult(); + return Optional.ofNullable(user); + } catch (NoResultException e) { + // skip + return Optional.empty(); + } finally { + em.getTransaction().commit(); + } + + } + + public Optional readByPlayerId(String playerId) { + try { + em.getTransaction().begin(); + User user = em.find(User.class, playerId); + return Optional.ofNullable(user); + } finally { + em.getTransaction().commit(); + } + } + + public Optional update(User person) { + try { + em.getTransaction().begin(); + person = em.merge(person); + em.flush(); + return Optional.of(person); + } finally { + em.getTransaction().commit(); + } + } +} diff --git a/src/main/resources/META-INF/persistence.xml b/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000..3ffe3c6 --- /dev/null +++ b/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,21 @@ + + + + de.Linus122.entity.User + true + + + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml index 519c210..df974ff 100755 --- a/src/main/resources/config.yml +++ b/src/main/resources/config.yml @@ -1,6 +1,6 @@ messages: # telegram messages - general-message-to-mc: "&c[Telegram]&r %s: %s" + general-message-to-mc: "&cYou got&r %.2f cashback" join-message: "`%s joined the game.`" quit-message: "`%s left the game.`" death-message: "`%s`" @@ -13,7 +13,10 @@ messages: no-permissions: "&cYou don't have permissions to use this!" cant-link-console: "&cSorry, but you can't link the console currently." need-to-add-bot-first: "&cPlease add a bot to your server first! /telegram" - get-token: "&aAdd %s to Telegram and send this message to %s: \n%s" + get-token: "&aAdd to Telegram and send this message to the bot: \n%s" + need-to-link-telegram-first: "&cPlease link your telegram to the game profile! */linktelegram*" + telegram-chat-on: "Telegram message settings have been changed!" + telegram-chat-off: "Telegram message settings have been changed!" enable-joinquitmessages: true enable-deathmessages: true enable-chatmessages: true diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 31f9e08..690535f 100755 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -1,15 +1,23 @@ -name: TelegramChat -main: de.Linus122.TelegramChat.TelegramChat -version: ${project.version} -authors: [Linus122] -softdepend: [Vault, SuperVanish, PremiumVanish] -description: Brings minecraft chat to Telegram! -commands: - telegram: - description: Main command - usage: / [token] - permission: telegram.settoken - linktelegram: - description: Main command - usage: / - permission: telegram.linktelegram +name: TelegramChat +main: de.Linus122.TelegramChat.TelegramChat +version: ${project.version} +authors: [Linus122] +softdepend: [Vault, SuperVanish, PremiumVanish, Chatty] +description: Brings minecraft chat to Telegram! +commands: + telegram: + description: Main command + usage: / [token] + permission: telegram.settoken + linktelegram: + description: Main command + usage: / + permission: telegram.linktelegram + tgon: + description: Turn on telegram messages + usage: / + permission: telegram.linktelegram + tgoff: + description: Turn off telegram messages + usage: / + permission: telegram.linktelegram