converted to maven, added API and issue fix

src/main/java/de/Linus122/Metrics/Metrics.java

@@ -0,0 +1,184 @@
+package de.Linus122.Metrics;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import javax.net.ssl.HttpsURLConnection;
+
+import org.bukkit.plugin.Plugin;
+
+import com.google.gson.Gson;
+
+
+/*
+ * SpaceIOMetrics main class by Linus122
+ * version: 0.05
+ * 
+ */
+public class Metrics {
+	private Plugin pl;
+	private final Gson gson = new Gson();
+	
+	private String URL = "https://spaceio.xyz/update/%s";
+	private final String VERSION = "0.05";
+	private int REFRESH_INTERVAL = 600000;
+	
+	public Metrics(Plugin pl){
+		this.pl = pl;
+		
+		// check if Metrics are disabled (checks if file "disablemetrics" is added to the plugins's folder
+		try {
+			Files.list(pl.getDataFolder().getParentFile().toPath()).filter(Files::isRegularFile).forEach(v -> {
+				if(v.getFileName().toString().equalsIgnoreCase("disablemetrics")){
+					return;
+				}
+			});
+		} catch (IOException e1) {
+			e1.printStackTrace();
+		}
+
+		URL = String.format(URL, pl.getName());
+		
+		// fetching refresh interval first
+		pl.getServer().getScheduler().runTaskLaterAsynchronously(pl, () -> {
+			String dataJson = collectData();
+			try{
+				REFRESH_INTERVAL = sendData(dataJson);
+			}catch(Exception e){}
+		}, 20L * 5);
+		
+		// executing repeating task, our main metrics updater
+		pl.getServer().getScheduler().runTaskTimerAsynchronously(pl, () -> {
+			String dataJson = collectData();
+			try{
+				sendData(dataJson);
+			}catch(Exception e){}
+			
+		}, 20L * (REFRESH_INTERVAL / 1000), 20L * (REFRESH_INTERVAL / 1000));
+	}
+	private String collectData() {
+		Data data = new Data();
+		
+		// collect plugin list
+		for(Plugin plug : pl.getServer().getPluginManager().getPlugins()) data.plugs.put(plug.getName(), plug.getDescription().getVersion());
+		
+		// fetch online players
+		data.onlinePlayers = pl.getServer().getOnlinePlayers().size();
+		
+		// server version
+		data.serverVersion = getVersion();
+		
+		// plugin version
+		data.pluginVersion = pl.getDescription().getVersion();
+		
+		// plugin author
+		data.pluginAuthors = pl.getDescription().getAuthors();
+		
+		// core count
+		data.coreCnt = Runtime.getRuntime().availableProcessors();
+		
+		// java version
+		data.javaRuntime = System.getProperty("java.runtime.version");
+		
+		// online mode
+		data.onlineMode = pl.getServer().getOnlineMode();
+
+		// software information
+		data.osName = System.getProperty("os.name");
+		data.osArch = System.getProperty("os.arch");
+		data.osVersion = System.getProperty("os.version");
+		
+		String executableName = new java.io.File(Metrics.class.getProtectionDomain()
+				  .getCodeSource()
+				  .getLocation()
+				  .getPath())
+				.getName();
+		data.executableName = executableName;
+		
+		data.diskSize = new File("/").getTotalSpace();
+		
+		if(data.osName.equals("Linux")){
+			data.linuxDistro = getDistro();
+		}
+		
+		return gson.toJson(data);
+	}
+	private int sendData(String dataJson) throws Exception{
+		java.net.URL obj = new java.net.URL(URL);
+		HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();
+
+		con.setRequestMethod("POST");
+		con.setRequestProperty("User-Agent", "Java/Bukkit");
+		con.setRequestProperty("Metrics-Version", this.VERSION);
+
+		con.setDoOutput(true);
+		DataOutputStream wr = new DataOutputStream(con.getOutputStream());
+		wr.writeBytes(dataJson);
+		wr.flush();
+		wr.close();
+		
+		return Integer.parseInt(con.getHeaderField("interval-millis"));
+	}
+	private String getVersion(){
+        String packageName = pl.getServer().getClass().getPackage().getName();
+        return  packageName.substring(packageName.lastIndexOf('.') + 1);
+	}
+	// method source: http://www.jcgonzalez.com/linux-get-distro-from-java-examples
+	private String getDistro(){
+		 //lists all the files ending with -release in the etc folder
+        File dir = new File("/etc/");
+        File fileList[] = new File[0];
+        if(dir.exists()){
+            fileList =  dir.listFiles(new FilenameFilter() {
+                public boolean accept(File dir, String filename) {
+                    return filename.endsWith("-release");
+                }
+            });
+        }
+        //looks for the version file (not all linux distros)
+        File fileVersion = new File("/proc/version");
+        if(fileVersion.exists()){
+            fileList = Arrays.copyOf(fileList,fileList.length+1);
+            fileList[fileList.length-1] = fileVersion;
+        }       
+        //prints first version-related file
+        for (File f : fileList) {
+            try {
+                BufferedReader br = new BufferedReader(new FileReader(f));
+                String strLine = null;
+                while ((strLine = br.readLine()) != null) {
+                    return strLine;
+                }
+                br.close();
+            } catch (Exception e) {}
+        }
+		return "unknown";    
+	}
+}
+class Data {
+	HashMap<String, String> plugs = new HashMap<String, String>();
+	int onlinePlayers;
+	String pluginVersion;
+	public List<String> pluginAuthors;
+	String serverVersion;
+	
+	long diskSize;
+	int coreCnt;
+	String javaRuntime;
+	
+	String executableName;
+	boolean onlineMode;
+	
+	String osName;
+	String osArch;
+	String osVersion;
+	String linuxDistro;
+}

src/main/java/de/Linus122/TelegramChat/API.java

@@ -0,0 +1,7 @@
+package de.Linus122.TelegramChat;
+
+public class API {
+	public static Telegram getTelegramHook(){
+		return Main.telegramHook;
+	}
+}

src/main/java/de/Linus122/TelegramChat/Data.java

@@ -0,0 +1,16 @@
+package de.Linus122.TelegramChat;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+public class Data {
+	public String token = "";
+	//Player name // ChatID
+	public HashMap<Integer, UUID> linkedChats = new HashMap<Integer, UUID>();
+	//Player name // RandomInt
+	public HashMap<String, UUID> linkCodes = new HashMap<String, UUID>();
+	public List<Integer> ids = new ArrayList<Integer>();
+	boolean firstUse = true;
+}

src/main/java/de/Linus122/TelegramChat/LinkTelegramCmd.java

@@ -0,0 +1,37 @@
+package de.Linus122.TelegramChat;
+
+import java.io.IOException;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class LinkTelegramCmd implements CommandExecutor {
+
+	@Override
+	public boolean onCommand(CommandSender cs, Command arg1, String arg2, String[] args) {
+		if(!(cs instanceof Player)){
+			cs.sendMessage("§cSorry, but you can't link the console currently.");
+		}
+		if(!cs.hasPermission("telegram.linktelegram")){
+			cs.sendMessage("§cYou don't have permissions to use this!");
+			return true;
+		}
+		if(Main.data == null){
+			Main.data = new Data();
+		}
+		if(Main.telegramHook.authJson == null){
+			cs.sendMessage("§cPlease add a bot to your server first! /telegram");
+			return true;
+		}
+		
+		String token = Main.generateLinkToken();
+		Main.data.linkCodes.put(token, ((Player) cs).getUniqueId());
+		cs.sendMessage("§aAdd " + Main.telegramHook.authJson.getAsJsonObject("result").get("username").getAsString() + " to Telegram and send this message to " + Main.telegramHook.authJson.getAsJsonObject("result").get("username").getAsString() + ":");
+		cs.sendMessage("§c" + token);
+		
+		return true;
+	}
+
+}

src/main/java/de/Linus122/TelegramChat/Main.java

@@ -0,0 +1,180 @@
+package de.Linus122.TelegramChat;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.URLEncoder;
+import java.text.Format;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.configuration.file.FileConfiguration;
+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.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.google.gson.Gson;
+
+import de.Linus122.Metrics.Metrics;
+import de.Linus122.TelegramComponents.Chat;
+import de.Linus122.TelegramComponents.ChatMessageToMc;
+
+
+public class Main extends JavaPlugin implements Listener{
+	public static File datad = new File("plugins/TelegramChat/data.json");
+	public static FileConfiguration cfg;
+	
+	public static Data data = new Data();
+	static Plugin pl;
+	public static Telegram telegramHook;
+	
+	@Override
+	public void onEnable(){
+		this.saveDefaultConfig();
+		cfg = this.getConfig();
+		this.pl = this;
+		Bukkit.getPluginCommand("telegram").setExecutor(new TelegramCmd());
+		Bukkit.getPluginCommand("linktelegram").setExecutor(new LinkTelegramCmd());
+		Bukkit.getPluginManager().registerEvents(this, this);
+		File dir = new File("plugins/TelegramChat/");
+		dir.mkdir();
+		data = new Data();
+		if(datad.exists()){
+			try {
+				FileInputStream fin = new FileInputStream(datad);
+				ObjectInputStream ois = new ObjectInputStream(fin);
+				Gson gson = new Gson();
+				data = (Data) gson.fromJson((String) ois.readObject(), Data.class);
+				ois.close();
+				fin.close();
+			} catch (Exception e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+		telegramHook = new Telegram();
+		telegramHook.auth(data.token);
+		
+		Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new Runnable(){
+			public void run(){
+				if(telegramHook.connected){
+					telegramHook.getUpdate();
+				}
+			}
+		}, 20L, 20L);
+		new Metrics(this);
+	}
+	public static void save(){
+		Gson gson = new Gson();
+		
+		try {
+			FileOutputStream fout= new FileOutputStream (datad);
+			ObjectOutputStream oos = new ObjectOutputStream(fout);
+			
+			oos.writeObject(gson.toJson(data));
+			fout.close();
+			oos.close();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	@Override
+	public void onDisable(){
+		save();
+	}
+	public static void sendToMC(ChatMessageToMc chatMsg) {
+		sendToMC(chatMsg.getUuid_sender(), chatMsg.getContent(), chatMsg.getChatID_sender());
+	}
+	private static void sendToMC(UUID uuid, String msg, int sender){
+		OfflinePlayer op = Bukkit.getOfflinePlayer(uuid);
+		List<Integer> recievers = new ArrayList<Integer>();
+		recievers.addAll(Main.data.ids);
+		recievers.remove((Object) sender);
+		String msgF = Main.cfg.getString("chat-format").replace('&', '§').replace("%player%", op.getName()).replace("%message%", msg);
+		for(int id : recievers){
+			telegramHook.sendMsg(id, msgF);
+		}
+		Bukkit.broadcastMessage(msgF.replace("&", "§"));
+	
+	}
+	public static void link(UUID player, int chatID){
+		Main.data.linkedChats.put(chatID, player);
+		OfflinePlayer p = Bukkit.getOfflinePlayer(player);
+		telegramHook.sendMsg(chatID, "Success! Linked " + p.getName());
+	}
+	public static String generateLinkToken(){
+		Random rnd = new Random();
+		int i = rnd.nextInt(9999999);
+		String s = i + "";
+		String finals = "";
+		for(char m : s.toCharArray()){
+			int m2 = Integer.parseInt(m + "");
+			int rndi = rnd.nextInt(2);
+			if(rndi == 0){
+				m2+=97;
+				char c = (char) m2;
+				finals = finals + c;
+			}else{
+				finals = finals + m;
+			}
+		}
+		return finals;
+	}
+	@EventHandler
+	public void onJoin(PlayerJoinEvent e){
+		if(!this.getConfig().getBoolean("enable-joinquitmessages")) return;
+		if(telegramHook.connected){
+			Chat chat = new Chat();
+			chat.parse_mode = "Markdown";
+			chat.text = "`" + e.getPlayer().getName() + " joined the game.`";
+			telegramHook.sendAll(chat);
+		}
+	}
+	@EventHandler
+	public void onDeath(PlayerDeathEvent e){
+		if(!this.getConfig().getBoolean("enable-deathmessages")) return;
+		if(telegramHook.connected){
+			Chat chat = new Chat();
+			chat.parse_mode = "Markdown";
+			chat.text = "`"+e.getDeathMessage() + "`";
+			telegramHook.sendAll(chat);
+		}
+	}
+	@EventHandler
+	public void onQuit(PlayerQuitEvent e){
+		if(!this.getConfig().getBoolean("enable-joinquitmessages")) return;
+		if(telegramHook.connected){
+			Chat chat = new Chat();
+			chat.parse_mode = "Markdown";
+			chat.text = "`" + e.getPlayer().getName() + " left the game.`";
+			System.out.println(chat.text);
+			telegramHook.sendAll(chat);
+		}
+	}
+	@EventHandler
+	public void onChat(AsyncPlayerChatEvent e){
+		if(!this.getConfig().getBoolean("enable-chatmessages")) return;
+		if(telegramHook.connected){
+			Chat chat = new Chat();
+			chat.parse_mode = "Markdown";
+			chat.text = escape(e.getPlayer().getName()) + ": _" + e.getMessage().replaceAll("§.", "") + "_";
+			telegramHook.sendAll(chat);
+		}
+	}
+	public String escape(String str){
+		return str.replace("_", "\\_");
+	}
+}

src/main/java/de/Linus122/TelegramChat/Telegram.java

@@ -0,0 +1,206 @@
+package de.Linus122.TelegramChat;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.HttpURLConnection;
+import java.net.URL;
+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.Chat;
+import de.Linus122.TelegramComponents.ChatMessageToMc;
+
+
+public class Telegram {
+	public JsonObject authJson;
+	public boolean connected = false;
+	
+	static int lastUpdate = 0;
+	public String token;
+
+	private List<TelegramActionListener> listeners = new ArrayList<TelegramActionListener>();
+	
+	public void addListener(TelegramActionListener actionListener){
+		listeners.add(actionListener);
+	}
+	
+	public boolean auth(String token){
+		this.token = token;
+		return reconnect();
+	}
+	public boolean reconnect(){
+		try{
+			JsonObject obj = sendGet("https://api.telegram.org/bot" + token + "/getMe");
+			authJson = obj;
+			connected = true;
+			return true;
+		}catch(Exception e){
+			connected = false;
+			System.out.print("[Telegram] Sorry, but could not connect to Telegram servers. The token could be wrong.");
+			return false;
+		}
+	}
+	public void getUpdate(){
+		JsonObject up = null;
+		try {
+			up = sendGet("https://api.telegram.org/bot" + Main.data.token + "/getUpdates?offset=" + (lastUpdate + 1));
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		if(up == null){
+			reconnect();
+		}
+		if(up.has("result")){
+			for (JsonElement ob : up.getAsJsonArray("result")) {
+				if (ob.isJsonObject()) {
+					JsonObject obj = (JsonObject) ob;
+					if(obj.has("update_id")){
+						lastUpdate = obj.get("update_id").getAsInt();
+					}
+					if (obj.has("message")) {
+						JsonObject chat = obj.getAsJsonObject("message").getAsJsonObject("chat");
+						if(chat.get("type").getAsString().equals("private")){
+							int id = chat.get("id").getAsInt();
+							if(!Main.data.ids.contains(id)) Main.data.ids.add(id);
+							
+							if(obj.getAsJsonObject("message").has("text")){
+								String text = obj.getAsJsonObject("message").get("text").getAsString();
+								for(char c : text.toCharArray()){
+									if((int) c == 55357){
+										this.sendMsg(id, "Emoticons are not allowed, sorry!");
+										return;
+									}
+								}
+								if(text.length() == 0) return;
+								if(text.equals("/start")){
+									if(Main.data.firstUse){
+										Main.data.firstUse = false;
+										Chat chat2 = new Chat();
+										chat2.chat_id = id;
+										chat2.parse_mode = "Markdown";
+										chat2.text = "Congratulations, your bot is working! Have fun with this Plugin. Feel free to donate via *PayPal* to me if you like TelegramChat! [PayPal Donation URL](https://goo.gl/I02XGH)";
+										this.sendMsg(chat2);
+									}
+									this.sendMsg(id, "You can see the chat but you can't chat at the moment. Type /linktelegram ingame to chat!");
+								}else
+								if(Main.data.linkCodes.containsKey(text)){
+									//LINK
+									Main.link(Main.data.linkCodes.get(text), id);
+									Main.data.linkCodes.remove(text);
+								}else if(Main.data.linkedChats.containsKey(id)){
+									ChatMessageToMc chatMsg = new ChatMessageToMc(Main.data.linkedChats.get(id), text, id);
+									for(TelegramActionListener actionListener : listeners){
+										actionListener.onSendToMinecraft(chatMsg);
+									}
+									Main.sendToMC(chatMsg);
+								}else{
+									this.sendMsg(id, "Sorry, please link your account with /linktelegram ingame to use the chat!");
+								}
+							}
+							
+						}else if(chat.get("type").getAsString().equals("group")){
+							int id = chat.get("id").getAsInt();
+							if(!Main.data.ids.contains(id))
+								Main.data.ids.add(id);
+						}
+					}
+					
+				}
+			}	
+		}
+	}
+	
+	public void sendMsg(int id, String msg){
+		Chat chat = new Chat();
+		chat.chat_id = id;
+		chat.text = msg;
+		sendMsg(chat);
+	}
+	public void sendMsg(Chat chat){
+		for(TelegramActionListener actionListener : listeners){
+			actionListener.onSendToTelegram(chat);
+		}
+		Gson gson = new Gson();
+		post("sendMessage", gson.toJson(chat, Chat.class));
+		
+	}
+	public void sendAll(final Chat chat){
+		new Thread(new Runnable(){
+			public void run(){
+				Gson gson = new Gson();
+				for(int id : Main.data.ids){
+					chat.chat_id = id;
+					//post("sendMessage", gson.toJson(chat, Chat.class));
+					sendMsg(chat);
+				}
+			}
+		}).start();
+	}
+	public void post(String method, String json){
+		try {
+			String body = json;
+			URL url = new URL("https://api.telegram.org/bot" + Main.data.token + "/" + method);
+			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+			connection.setRequestMethod("POST");
+			connection.setDoInput(true);
+			connection.setDoOutput(true);
+			connection.setUseCaches(false);
+			connection.setRequestProperty("Content-Type", "application/json; ; Charset=UTF-8");
+			connection.setRequestProperty("Content-Length", String.valueOf(body.length()));
+
+			
+			DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
+			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(wr, "UTF-8"));
+			writer.write(body);
+			writer.close();
+			wr.close();
+			
+			//OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream());
+			//writer.write(body);
+			//writer.flush();
+
+			BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+
+			for (String line; (line = reader.readLine()) != null;) {
+				
+			}
+
+			writer.close();
+			reader.close();
+		} catch (Exception e) {
+			reconnect();
+			System.out.print("[Telegram] Disconnected from Telegram, reconnect...");
+		}
+		
+	}
+
+	public JsonObject sendGet(String url) throws IOException {
+		String a = url;
+		URL url2 = new URL(a);
+		URLConnection conn = url2.openConnection();
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+
+		String all = "";
+		String inputLine;
+		while ((inputLine = br.readLine()) != null) {
+			all += inputLine;
+		}
+
+		br.close();
+		JsonParser parser = new JsonParser();
+		return parser.parse(all).getAsJsonObject();
+
+	}
+}

src/main/java/de/Linus122/TelegramChat/TelegramActionListener.java

@@ -0,0 +1,9 @@
+package de.Linus122.TelegramChat;
+
+import de.Linus122.TelegramComponents.Chat;
+import de.Linus122.TelegramComponents.ChatMessageToMc;
+
+public interface TelegramActionListener {
+	public void onSendToTelegram(Chat chat);
+	public void onSendToMinecraft(ChatMessageToMc chatMsg);
+}

src/main/java/de/Linus122/TelegramChat/TelegramCmd.java

@@ -0,0 +1,36 @@
+package de.Linus122.TelegramChat;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class TelegramCmd implements CommandExecutor {
+
+	@Override
+	public boolean onCommand(CommandSender cs, Command arg1, String arg2, String[] args) {
+		if(!cs.hasPermission("telegram.settoken")){
+			cs.sendMessage("§cYou don't have permissions to use this!");
+			return true;
+		}
+		if(args.length == 0){
+			cs.sendMessage("§c/telegram [token]");
+			return true;
+		}
+		if(Main.data == null){
+			Main.data = new Data();
+		}
+		Main.data.token = args[0];
+		Main.save();
+		boolean success = false;
+	
+		success = Main.telegramHook.auth(Main.data.token);
+		if(success){
+			cs.sendMessage("§cSuccessfully connected to Telegram!");
+			cs.sendMessage("§aAdd " + Main.telegramHook.authJson.getAsJsonObject("result").get("username").getAsString() + " to Telegram!");
+		}else{
+			cs.sendMessage("§cWrong token. Paste in the whole token!");
+		}
+		return true;
+	}
+
+}

src/main/java/de/Linus122/TelegramComponents/Chat.java

@@ -0,0 +1,7 @@
+package de.Linus122.TelegramComponents;
+
+public class Chat {
+	public String text;
+	public int chat_id;
+	public String parse_mode;
+}

src/main/java/de/Linus122/TelegramComponents/ChatMessageToMc.java

@@ -0,0 +1,39 @@
+package de.Linus122.TelegramComponents;
+
+import java.util.UUID;
+
+public class ChatMessageToMc {
+	UUID uuid_sender;
+	String content;
+	int chatID_sender;
+	
+	public ChatMessageToMc(UUID uuid_sender, String content, int chatID_sender){
+		this.uuid_sender = uuid_sender;
+		this.content = content;
+		this.chatID_sender = chatID_sender;
+	}
+
+	public UUID getUuid_sender() {
+		return uuid_sender;
+	}
+
+	public void setUuid_sender(UUID uuid_sender) {
+		this.uuid_sender = uuid_sender;
+	}
+
+	public String getContent() {
+		return content;
+	}
+
+	public void setContent(String content) {
+		this.content = content;
+	}
+
+	public int getChatID_sender() {
+		return chatID_sender;
+	}
+
+	public void setChatID_sender(int chatID_sender) {
+		this.chatID_sender = chatID_sender;
+	}
+}

src/main/resources/config.yml

@@ -0,0 +1,4 @@
+chat-format: '&c[Telegram]&r %player%: %message%'
+enable-joinquitmessages: true
+enable-deathmessages: true
+enable-chatmessages: true

src/main/resources/plugin.yml

@@ -0,0 +1,14 @@
+name: TelegramChat
+main: de.Linus122.TelegramChat.Main
+version: ${project.version}
+authors: [Linus122]
+description: Brings minecraft chat to Telegram!
+commands:
+   telegram:
+      description: Main command
+      usage: /<command> [token]
+      permission: telegram.settoken
+   linktelegram:
+      description: Main command
+      usage: /<command>
+      permission: telegram.linktelegram