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