· 6 years ago · Jul 03, 2019, 07:52 PM
1package de.rtx_.clans.utils;
2
3import java.sql.PreparedStatement;
4import java.sql.ResultSet;
5import java.sql.SQLException;
6import java.text.DecimalFormat;
7import java.util.ArrayList;
8import java.util.HashMap;
9import java.util.List;
10import java.util.UUID;
11
12public class Clans {
13
14////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
15
16 /*
17 * \
18 *
19 * CLAN-SYSTEM
20 *
21 * \
22 */
23
24 public Clans() {
25 }
26
27 /*
28 * \
29 *
30 * BOOLEANS
31 *
32 * \
33 */
34
35 public void createTables() {
36 try {
37 MySQL.getStatement(
38 "CREATE TABLE IF NOT EXISTS Clans (Name VARCHAR(100), Tag VARCHAR(100), OwnerUUID VARCHAR(100), OwnerName VARCHAR(100), Mitgliederzahl VARCHAR(100), Kills VARCHAR(100), Tode VARCHAR(100), Level VARCHAR(100))")
39 .executeUpdate();
40 MySQL.getStatement(
41 "CREATE TABLE IF NOT EXISTS ClanMember (ClanName VARCHAR(100), UserUUID VARCHAR(100), UserName VARCHAR(100), ClanRang VARCHAR(100))")
42 .executeUpdate();
43 } catch (SQLException e) {
44 System.err.println("TagPvP.de Clans - Fehler mit der MySQL-Verbindung!");
45 }
46 }
47
48 public boolean isExistByName(String clanName) {
49
50 boolean b = false;
51
52 try {
53 PreparedStatement ps = MySQL.getStatement("SELECT Name FROM Clans WHERE Name = ?");
54 ps.setString(1, clanName);
55 ResultSet rs = ps.executeQuery();
56 if (rs.next()) {
57 b = true;
58 }
59 } catch (SQLException e) {
60 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (isExistByName)");
61 }
62
63 return b;
64
65 }
66
67 public boolean isExistByTag(String clanTag) {
68
69 boolean b = false;
70
71 try {
72 PreparedStatement ps = MySQL.getStatement("SELECT Tag FROM Clans WHERE Tag = ?");
73 ps.setString(1, clanTag);
74 ResultSet rs = ps.executeQuery();
75 if (rs.next()) {
76 b = true;
77 }
78 } catch (SQLException e) {
79 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (isExistByTag)");
80 }
81
82 return b;
83
84 }
85
86 public boolean isTrusted(String userName) {
87 boolean b = false;
88 try {
89 PreparedStatement ps = MySQL.getStatement("SELECT ClanRang FROM ClanMember WHERE UserName = ?");
90 ps.setString(1, userName);
91 ResultSet rs = ps.executeQuery();
92 if (rs.next()) {
93 if (rs.getString("ClanRang").equals("Trusted")) {
94 b = true;
95 }
96 }
97 } catch (SQLException e) {
98 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (isTrusted)");
99 }
100 return b;
101 }
102
103 public boolean isInClan(String userName) {
104 boolean b = false;
105 try {
106 PreparedStatement ps = MySQL.getStatement("SELECT ClanName FROM ClanMember WHERE UserName = ?");
107 ps.setString(1, userName);
108 ResultSet rs = ps.executeQuery();
109 if (rs.next()) {
110 b = true;
111 }
112 } catch (SQLException e) {
113 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (isInClan)");
114 }
115 return b;
116 }
117
118 public boolean isOwner(String userName) {
119 boolean b = false;
120 try {
121 PreparedStatement ps = MySQL.getStatement("SELECT ClanRang FROM ClanMember WHERE UserName = ?");
122 ps.setString(1, userName);
123 ResultSet rs = ps.executeQuery();
124 if (rs.next()) {
125 if (rs.getString("ClanRang").equals("Leader")) {
126 b = true;
127 }
128 }
129 } catch (SQLException e) {
130 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (isOwner)");
131 }
132 return b;
133 }
134
135 public HashMap<String, Integer> getClanKillRanking() {
136 HashMap<String, Integer> killtops = new HashMap<String, Integer>();
137 try {
138 PreparedStatement ps = MySQL.getStatement("SELECT ClanName, Kills FROM Clans ORDER BY Kills ASC LIMIT 5");
139 ResultSet rs = ps.executeQuery();
140 while (rs.next()) {
141 String clanName = rs.getString("ClanName");
142 killtops.put(clanName, Integer.valueOf(rs.getString("Kills")));
143 }
144 } catch (SQLException e) {
145 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getClanKillRanking)");
146 }
147 return killtops;
148 }
149
150 public HashMap<String, Integer> getClanLevelRanking() {
151 HashMap<String, Integer> killtops = new HashMap<String, Integer>();
152 try {
153 PreparedStatement ps = MySQL.getStatement("SELECT ClanName, Level FROM Clans ORDER BY Level ASC LIMIT 5");
154 ResultSet rs = ps.executeQuery();
155 while (rs.next()) {
156 String clanName = rs.getString("ClanName");
157 killtops.put(clanName, Integer.valueOf(rs.getString("Level")));
158 }
159 } catch (SQLException e) {
160 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getClanLevelRanking)");
161 }
162 return killtops;
163 }
164
165 /*
166 * \
167 *
168 * CLANS ERSTELLEN UND LÖSCHEN
169 *
170 * \
171 */
172
173 public void deleteClan(String clanName) {
174
175 try {
176 PreparedStatement ps1 = MySQL.getStatement("DELETE FROM Clans WHERE Name = ?");
177 ps1.setString(1, clanName);
178 ps1.executeUpdate();
179 ps1.close();
180
181 PreparedStatement ps2 = MySQL.getStatement("DELETE FROM ClanMember WHERE ClanName = ?");
182 ps2.setString(2, clanName);
183 ps2.executeUpdate();
184 ps2.close();
185 } catch (SQLException e) {
186 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (deleteClan)");
187 }
188
189 }
190
191 public void createClan(String ownerName, UUID ownerUUID, String clanName, String clanTag) {
192
193 try {
194 PreparedStatement ps1 = MySQL.getStatement(
195 "INSERT INTO Clans (Name, Tag, OwnerUUID, OwnerName, Mitgliederzahl, Kills, Level) VALUES (?,?,?,?,?,?,?)");
196 ps1.setString(1, clanName);
197 ps1.setString(2, clanTag);
198 ps1.setString(3, ownerUUID.toString());
199 ps1.setString(4, ownerName);
200 ps1.setString(5, "1");
201 ps1.setString(6, "0");
202 ps1.setString(7, "1");
203 ps1.executeUpdate();
204 ps1.close();
205
206 PreparedStatement ps2 = MySQL
207 .getStatement("INSERT INTO ClanMember (ClanName, UserUUID, UserName, ClanRang) VALUES (?,?,?,?)");
208 ps2.setString(1, clanName);
209 ps2.setString(2, ownerUUID.toString());
210 ps2.setString(3, ownerName);
211 ps2.setString(4, "Leader");
212 ps2.executeUpdate();
213 ps2.close();
214 } catch (SQLException e) {
215 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (createClan)");
216 }
217 }
218
219 /*
220 * \
221 *
222 * Abfragen
223 *
224 * \
225 */
226
227 public ArrayList<String> getMemberList(String clanName) {
228 ArrayList<String> members = new ArrayList<String>();
229 try {
230 PreparedStatement ps = MySQL.getStatement("SELECT UserName FROM ClanMember WHERE ClanName = ?");
231 ps.setString(1, clanName);
232 ResultSet rs = ps.executeQuery();
233 while (rs.next()) {
234 if (!(members.contains(rs.getString("UserName"))) && !(isTrusted(rs.getString("UserName")))) {
235 members.add("§7" + rs.getString("UserName"));
236 }
237 }
238 ps.close();
239 } catch (SQLException e) {
240 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getMemberList)");
241 }
242
243 return members;
244 }
245
246 public ArrayList<String> getExactMemberList(String clanName) {
247 ArrayList<String> members = new ArrayList<String>();
248 try {
249 PreparedStatement ps = MySQL.getStatement("SELECT UserName FROM ClanMember WHERE ClanName = ?");
250 ps.setString(1, clanName);
251 ResultSet rs = ps.executeQuery();
252 while (rs.next()) {
253 if (!(members.contains(rs.getString("UserName")))) {
254 members.add(rs.getString("UserName"));
255 }
256 }
257 ps.close();
258 } catch (SQLException e) {
259 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getMemberList)");
260 }
261
262 return members;
263 }
264
265 public int getKills(String clanName) {
266 int i = 0;
267 try {
268 PreparedStatement ps = MySQL.getStatement("SELECT Kills FROM Clans WHERE ClanName = ?");
269 ps.setString(1, clanName);
270 ResultSet rs = ps.executeQuery();
271 if (rs.next()) {
272 i = Integer.valueOf(rs.getString("Kills"));
273 }
274 ps.close();
275 } catch (SQLException e) {
276 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getKills)");
277 }
278 return i;
279 }
280
281 public int getDeaths(String clanName) {
282 int i = 0;
283 try {
284 PreparedStatement ps = MySQL.getStatement("SELECT Tode FROM Clans WHERE ClanName = ?");
285 ps.setString(1, clanName);
286 ResultSet rs = ps.executeQuery();
287 if (rs.next()) {
288 i = Integer.valueOf(rs.getString("Tode"));
289 }
290 ps.close();
291 } catch (SQLException e) {
292 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getDeaths)");
293 }
294 return i;
295 }
296
297 public String getKD(String clanName) {
298 String kd = "";
299 double kills = Double.valueOf(getKills(clanName));
300 double deaths = Double.valueOf(getDeaths(clanName));
301 double difference = kills / deaths;
302
303 DecimalFormat format = new DecimalFormat("#.##");
304 kd = format.format(difference);
305
306 return kd;
307 }
308
309 public int getLevel(String clanName) {
310 int i = 0;
311 try {
312 PreparedStatement ps = MySQL.getStatement("SELECT Level FROM Clans WHERE ClanName = ?");
313 ps.setString(1, clanName);
314 ResultSet rs = ps.executeQuery();
315 if (rs.next()) {
316 i = Integer.valueOf(rs.getString("Level"));
317 }
318 ps.close();
319 } catch (SQLException e) {
320 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getLevel)");
321 }
322 return i;
323 }
324
325 public void addKill(String clanName) {
326 try {
327 PreparedStatement ps = MySQL.getStatement("UPDATE Clans SET Kills = ? WHERE ClanName = ?");
328 ps.setString(1, String.valueOf(getKills(clanName) + 1));
329 ps.setString(2, clanName);
330 ps.executeUpdate();
331 ps.close();
332
333 if (getKills(clanName) == 10 && getLevel(clanName) == 1) {
334 levelUP(clanName);
335 } else if (getKills(clanName) == 20 && getLevel(clanName) == 2) {
336 levelUP(clanName);
337 } else if (getKills(clanName) == 30 && getLevel(clanName) == 3) {
338 levelUP(clanName);
339 } else if (getKills(clanName) == 40 && getLevel(clanName) == 4) {
340 levelUP(clanName);
341 } else if (getKills(clanName) == 50 && getLevel(clanName) == 5) {
342 levelUP(clanName);
343 }
344 } catch (SQLException e) {
345 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (addKill)");
346 }
347 }
348
349 public void addDeath(String clanName) {
350 try {
351 PreparedStatement ps = MySQL.getStatement("UPDATE Clans SET Tode = ? WHERE ClanName = ?");
352 ps.setString(1, String.valueOf(getKills(clanName) + 1));
353 ps.setString(2, clanName);
354 ps.executeUpdate();
355 ps.close();
356 } catch (SQLException e) {
357 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (addDeath)");
358 }
359 }
360
361 public void levelUP(String clanName) {
362 try {
363 PreparedStatement ps = MySQL.getStatement("UPDATE Clans SET Level = ? WHERE ClanName = ?");
364 ps.setString(1, String.valueOf(getLevel(clanName) + 1));
365 ps.setString(2, clanName);
366 ps.executeUpdate();
367 ps.close();
368 } catch (SQLException e) {
369 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (levelUP)");
370 }
371 }
372
373 public String getColoredTag(String userName) {
374 String s = "";
375 if (getLevel(getClanName(userName)) == 1) {
376 s = "§2" + getClanTag(userName);
377 } else if (getLevel(getClanName(userName)) == 2) {
378 s = "§a" + getClanTag(userName);
379 } else if (getLevel(getClanName(userName)) == 3) {
380 s = "§e" + getClanTag(userName);
381 } else if (getLevel(getClanName(userName)) == 4) {
382 s = "§6" + getClanTag(userName);
383 } else if (getLevel(getClanName(userName)) == 5) {
384 s = "§c" + getClanTag(userName);
385 } else if (getLevel(getClanName(userName)) == 6) {
386 s = "§4" + getClanTag(userName);
387 }
388 return s;
389 }
390
391 public String getClanOwner(String clanName) {
392 String owner = "";
393
394 try {
395 PreparedStatement ps = MySQL.getStatement("SELECT OwnerName FROM Clans WHERE ClanName = ?");
396 ps.setString(1, clanName);
397 ResultSet rs = ps.executeQuery();
398 if (rs.next()) {
399 owner = "§7" + rs.getString("OwnerName");
400 }
401 ps.close();
402 } catch (SQLException e) {
403 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getClanOwner)");
404 }
405
406 return owner;
407 }
408
409 public List<String> getTrustedMembers(String clanName) {
410 List<String> trusted = new ArrayList<String>();
411
412 try {
413 PreparedStatement ps = MySQL
414 .getStatement("SELECT UserName FROM ClanMember WHERE ClanName = ? AND ClanRang = ?");
415 ps.setString(1, clanName);
416 ps.setString(2, "Trusted");
417 ResultSet rs = ps.executeQuery();
418 while (rs.next()) {
419 if (!(trusted.contains(rs.getString("UserName")))) {
420 trusted.add("§7" + rs.getString("UserName"));
421 }
422 }
423 ps.close();
424 } catch (SQLException e) {
425 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getTrustedMembers)");
426 }
427
428 return trusted;
429 }
430
431 public String getClanName(String userName) {
432 String clan = "";
433 try {
434 PreparedStatement ps = MySQL.getStatement("SELECT ClanName FROM ClanMember WHERE UserName = ?");
435 ps.setString(1, userName);
436 ResultSet rs = ps.executeQuery();
437 if (rs.next()) {
438 clan = rs.getString("ClanName");
439 }
440 ps.close();
441 } catch (SQLException e) {
442 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getClanName)");
443 }
444 return clan;
445 }
446
447 public String getClanTag(String userName) {
448 String tag = "";
449 try {
450 PreparedStatement ps = MySQL.getStatement("SELECT Tag FROM Clans WHERE Name = ?");
451 ps.setString(1, getClanName(userName));
452 ResultSet rs = ps.executeQuery();
453 if (rs.next()) {
454 tag = rs.getString("Tag");
455 }
456 ps.close();
457 } catch (SQLException e) {
458 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getClanTag)");
459 }
460 return tag;
461 }
462
463 public int getMitgliederAnzahl(String clanName) {
464 int anzahl = 0;
465 try {
466 PreparedStatement ps = MySQL.getStatement("SELECT Mitgliederanzahl FROM Clans WHERE Name = ?");
467 ps.setString(1, clanName);
468 ResultSet rs = ps.executeQuery();
469 if (rs.next()) {
470 anzahl = Integer.valueOf(rs.getString("Mitgliederanzahl"));
471 }
472 ps.close();
473 } catch (SQLException e) {
474 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Abfrage! (getMitgliederAnzahl)");
475 }
476 return anzahl;
477 }
478
479 /*
480 * \
481 *
482 * Member Clanregister, Member Kick, Rang setten
483 *
484 * \
485 */
486
487 public void addMemberToClan(String clanName, UUID userUUID, String userName) {
488 try {
489 PreparedStatement ps2 = MySQL
490 .getStatement("INSERT INTO ClanMember (ClanName, UserUUID, UserName, ClanRang) VALUES (?,?,?,?)");
491 ps2.setString(1, clanName);
492 ps2.setString(2, userUUID.toString());
493 ps2.setString(3, userName);
494 ps2.setString(4, "Member");
495 ps2.executeUpdate();
496 ps2.close();
497 } catch (SQLException e) {
498 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (addMemberToClan)");
499 }
500 }
501
502 public void kickPlayerFromClan(UUID userUUID) {
503 try {
504 PreparedStatement ps2 = MySQL.getStatement("DELETE FROM ClanMember WHERE UserUUID = ?");
505 ps2.setString(1, userUUID.toString());
506 ps2.executeUpdate();
507 ps2.close();
508 } catch (SQLException e) {
509 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (kickPlayerFromClan)");
510 }
511 }
512
513 public void setRang(UUID userUUID, String rang) {
514 try {
515 PreparedStatement ps2 = MySQL.getStatement("UPDATE ClanMember SET ClanRang = ? WHERE UserUUID = ?");
516 ps2.setString(1, rang);
517 ps2.setString(2, userUUID.toString());
518 ps2.executeUpdate();
519 ps2.close();
520 } catch (SQLException e) {
521 System.err.println("TagPvP.de Clans - Fehler bei MySQL-Befehl! (kickPlayerFromClan)");
522 }
523 }
524
525////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
526
527}