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