API tools faq
paste
Guest User

Untitled

a guest
Oct 10th, 2017
33
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 91.02 KB | None | 0 0
raw download clone embed print report
  1. package server.database.util;
  2.  
  3. import java.sql.PreparedStatement;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Timestamp;
  7. import java.util.ArrayList;
  8. import java.util.HashMap;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.function.Consumer;
  12.  
  13. import com.google.gson.Gson;
  14.  
  15. import server.Config;
  16. import server.Server;
  17. import server.content.Lottery;
  18. import server.content.Lottery.LotteryEntry;
  19. import server.content.ReaperCollection.ReaperCollectionItem;
  20. import server.content.ShopSale.SaleType;
  21. import server.content.ShopSale.ShopSaleItem;
  22. import server.content.VoteContest;
  23. import server.content.VoteContest.ContestWinners;
  24. import server.content.VoteLottery;
  25. import server.database.GameDatabase;
  26. import server.database.model.RequestModel;
  27. import server.database.model.RequestModel.QueryType;
  28. import server.database.model.impl.PremiumExtractDAO;
  29. import server.database.model.impl.PremiumExtractDAO.ExtractType;
  30. import server.database.passive.PassiveDatabaseWorker;
  31. import server.database.pooled.DatabaseConnection;
  32. import server.model.client.interfaces.InterfaceHandler;
  33. import server.model.client.interfaces.TextScroll;
  34. import server.model.dialogue.DialogueChat;
  35. import server.model.dialogue.DialogueManager;
  36. import server.model.items.GameItem;
  37. import server.model.items.ItemHandler;
  38. import server.model.items.bank.BankConstants;
  39. import server.model.items.bank.BankWrapper;
  40. import server.model.players.Client;
  41. import server.model.players.Player;
  42. import server.model.players.PlayerHandler;
  43. import server.model.players.moderation.PlayerPunishment;
  44. import server.model.players.moderation.PlayerPunishment.PunishmentType;
  45. import server.model.players.moderation.PunishHandler;
  46. import server.refactor.StreamHandler;
  47. import server.util.BCrypt;
  48. import server.util.Misc;
  49. import server.util.Tuple;
  50.  
  51. public class PlayerDatabase {
  52.  
  53. private static String credentialQuery, credentialOldQuery,
  54. accountDeleteQuery, nameChangeQuery, playerIDGatheringQuery,
  55. supportGroupQuery;
  56.  
  57. /**
  58. * Prepare statements to be used in a later time.
  59. */
  60. public static void prepareStatements() {
  61. credentialQuery = "select connectedFrom, regSerial, playerMacAdress from clients where playerName = ?;";
  62. credentialOldQuery = "select connectedFrom, regSerial, playerMacAdress from clients_old where playerName = ?;";
  63. accountDeleteQuery = "delete from clients where playerName = ?;";
  64. nameChangeQuery = "update clients set playerName = ? where playerName = ?;";
  65. playerIDGatheringQuery = "select dbid from clients where playerName = ?;";
  66. supportGroupQuery = "select count(*) from supportgroup s left join clients c on s.playerName = c.playerName where c.regSerial = ? || s.playerName = ?;";
  67. }
  68.  
  69. public static String insertToLottery(Client c, int entryFee) {
  70. String resultMessage = null;
  71.  
  72. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "52");
  73. if (databaseConnection == null) {
  74. GameDatabase.getActionManager().reportUnavailableConnection();
  75. return "Sorry, we were unable to insert you into the lottery.";
  76. }
  77.  
  78. PreparedStatement registerStatement = databaseConnection.prepareStatement("insert lottery (playerID, entryFee) values(?, ?);");
  79. try {
  80. registerStatement.setInt(1, c.accountID);
  81. registerStatement.setInt(2, entryFee);
  82. registerStatement.execute();
  83. return "Your entry was submited, good luck!";
  84. } catch (SQLException e) {
  85. if (e.getErrorCode() == 1062) {
  86. resultMessage = "You're already betting at lottery.";
  87. } else {
  88. resultMessage = "Failed to bet.";
  89. e.printStackTrace();
  90. }
  91. } finally {
  92. databaseConnection.close(registerStatement);
  93. databaseConnection.release();
  94. }
  95.  
  96. return resultMessage;
  97. }
  98.  
  99. public static int getLotteryEntryCount() {
  100. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "83");
  101. if (databaseConnection == null) {
  102. GameDatabase.getActionManager().reportUnavailableConnection();
  103. return -1;
  104. }
  105. PreparedStatement totalEntryCheck = null;
  106.  
  107. try {
  108. totalEntryCheck = databaseConnection.prepareStatement("select count(*) from lottery;");
  109. ResultSet rs = totalEntryCheck.executeQuery();
  110. if (rs.next()) {
  111. return rs.getInt(1);
  112. }
  113. } catch (SQLException ex) {
  114. ex.printStackTrace();
  115. } finally {
  116. databaseConnection.close(totalEntryCheck);
  117. databaseConnection.release();
  118. }
  119. return 0;
  120. }
  121.  
  122. public static long getTotalLotteryEntry() {
  123. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "105");
  124. if (databaseConnection == null) {
  125. GameDatabase.getActionManager().reportUnavailableConnection();
  126. return -1;
  127. }
  128. PreparedStatement totalEntryCheck = null;
  129.  
  130. try {
  131. totalEntryCheck = databaseConnection.prepareStatement("select sum(entryFee) from lottery;");
  132. ResultSet rs = totalEntryCheck.executeQuery();
  133. if (rs.next()) {
  134. return rs.getLong(1);
  135. }
  136. } catch (SQLException ex) {
  137. ex.printStackTrace();
  138. } finally {
  139. databaseConnection.close(totalEntryCheck);
  140. databaseConnection.release();
  141. }
  142. return 0;
  143. }
  144.  
  145. public static ArrayList<String> checkLotteryHistory() {
  146. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "105");
  147. if (databaseConnection == null) {
  148. GameDatabase.getActionManager().reportUnavailableConnection();
  149. return null;
  150. }
  151.  
  152. ArrayList<String> history = new ArrayList<String>();
  153.  
  154. PreparedStatement historyStatement = databaseConnection.prepareStatement("select playerName, winnerEntry, winnerReward, updateTime from lotteryhistory join clients on dbid = winnerID order by updateTime desc limit 15;");
  155. ResultSet rs = null;
  156. try {
  157. rs = historyStatement.executeQuery();
  158. while (rs.next()) {
  159. String playerName = rs.getString(1);
  160. long rewardValue = rs.getLong(3);
  161. history.add(Misc.capitalize(playerName) + " - " + Misc.getShopPrice(rewardValue) + " coins.");
  162. }
  163. return history;
  164. } catch (SQLException e) {
  165. e.printStackTrace();
  166. } finally {
  167. databaseConnection.close(historyStatement);
  168. databaseConnection.close(rs);
  169. databaseConnection.release();
  170. }
  171. return null;
  172. }
  173.  
  174. public static LotteryEntry getRandomLotteryWinner() {
  175.  
  176. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "83");
  177. if (databaseConnection == null) {
  178. GameDatabase.getActionManager().reportUnavailableConnection();
  179. return null;
  180. }
  181.  
  182. PreparedStatement sortStatement = databaseConnection.prepareStatement("select playerID, playerName, entryFee from lottery join clients c on c.dbid = playerID order by rand() limit 0, 1;");
  183. ResultSet rs = null;
  184. try {
  185. rs = sortStatement.executeQuery();
  186. if (rs.next()) {
  187. int playerID = rs.getInt(1);
  188. String playerName = rs.getString(2);
  189. int entryFee = rs.getInt(3);
  190. return new Lottery.LotteryEntry(playerID, entryFee, playerName);
  191. }
  192. } catch (SQLException e) {
  193. e.printStackTrace();
  194. } finally {
  195. databaseConnection.close(sortStatement);
  196. databaseConnection.close(rs);
  197. databaseConnection.release();
  198. }
  199.  
  200. return null;
  201. }
  202.  
  203. public static int getLotteryEntryCount(Client c) {
  204. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "163");
  205. if (databaseConnection == null) {
  206. GameDatabase.getActionManager().reportUnavailableConnection();
  207. return 0;
  208. }
  209. PreparedStatement entryCheck = null;
  210. ResultSet rs = null;
  211. try {
  212. entryCheck = databaseConnection.prepareStatement("select count(*) from lottery where playerID = ?;");
  213. entryCheck.setInt(1, c.accountID);
  214. rs = entryCheck.executeQuery();
  215. if (rs.next()) {
  216. int count = rs.getInt(1);
  217. return count;
  218. }
  219. } catch (SQLException ex) {
  220. ex.printStackTrace();
  221. } finally {
  222. databaseConnection.close(entryCheck);
  223. databaseConnection.close(rs);
  224. databaseConnection.release();
  225. }
  226. return 0;
  227. }
  228.  
  229. public static boolean finishLottery(LotteryEntry winner) {
  230. if (winner == null) {
  231. return false;
  232. }
  233. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "163");
  234. if (databaseConnection == null) {
  235. GameDatabase.getActionManager().reportUnavailableConnection();
  236. return false;
  237. }
  238. PreparedStatement clearStatement = null;
  239. PreparedStatement historyInsert = null;
  240. try {
  241. clearStatement = databaseConnection.prepareStatement("truncate lottery;");
  242. historyInsert = databaseConnection.prepareStatement("insert into lotteryhistory (winnerID, winnerEntry, winnerReward, totalEntry) values (?, ?, ?, ?);");
  243. long totalEntry = winner.getTotalEntry();
  244. int winnerID = winner.getPlayerID();
  245. long winnerFee = winner.getEntryFee();
  246.  
  247. long winnerReward = winner.getLotteryReward();
  248. historyInsert.setInt(1, winnerID);
  249. historyInsert.setInt(2, (int) winnerFee);
  250. historyInsert.setLong(3, winnerReward);
  251. historyInsert.setLong(4, totalEntry);
  252. historyInsert.executeUpdate();
  253. clearStatement.executeUpdate();
  254. } catch (SQLException ex) {
  255. ex.printStackTrace();
  256. } finally {
  257. databaseConnection.close(clearStatement);
  258. databaseConnection.close(historyInsert);
  259. databaseConnection.release();
  260. }
  261.  
  262. return false;
  263. }
  264.  
  265. public static int deletePlayer(String playerName) {
  266. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "163");
  267. if (databaseConnection == null) {
  268. GameDatabase.getActionManager().reportUnavailableConnection();
  269. return -1;
  270. }
  271. PreparedStatement deleteStatement = databaseConnection.prepareStatement(accountDeleteQuery);
  272. try {
  273. deleteStatement.setString(1, playerName);
  274. int rowsAffected = deleteStatement.executeUpdate();
  275. return rowsAffected;
  276. } catch (SQLException e) {
  277. e.printStackTrace();
  278. } finally {
  279. databaseConnection.close(deleteStatement);
  280. databaseConnection.release();
  281. }
  282. return 0;
  283. }
  284.  
  285. public static int updateName(String playerName, String newName) {
  286. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "183");
  287. if (databaseConnection == null) {
  288. GameDatabase.getActionManager().reportUnavailableConnection();
  289. return -1;
  290. }
  291. PreparedStatement updateStatement = databaseConnection.prepareStatement(nameChangeQuery);
  292. try {
  293. updateStatement.setString(1, newName);
  294. updateStatement.setString(2, playerName);
  295. int rowsAffected = updateStatement.executeUpdate();
  296. return rowsAffected;
  297. } catch (SQLException e) {
  298. e.printStackTrace();
  299. } finally {
  300. databaseConnection.close(updateStatement);
  301. databaseConnection.release();
  302. }
  303. return 0;
  304. }
  305.  
  306. public static int getPlayerID(String playerName) {
  307.  
  308. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "205");
  309. if (databaseConnection == null) {
  310. GameDatabase.getActionManager().reportUnavailableConnection();
  311. return -2;
  312. }
  313.  
  314. ResultSet rs = null;
  315. PreparedStatement credentialStatement = databaseConnection.prepareStatement("select dbid from clients where playerName = ?;");
  316. try {
  317. credentialStatement.setString(1, playerName);
  318. rs = credentialStatement.executeQuery();
  319. // boolean found = rs.next();
  320. // if (!found) {
  321. // rs.close();
  322. // credentialStatement =
  323. // databaseConnection.prepareStatement(credentialOldQuery);
  324. // credentialStatement.setString(1, playerName);
  325. // rs = credentialStatement.executeQuery();
  326. // found = rs.next();
  327. // }
  328. if (rs.next()) {
  329. int playerID = rs.getInt(1);
  330. return playerID;
  331. }
  332. } catch (SQLException e) {
  333. e.printStackTrace();
  334. } finally {
  335. databaseConnection.close(credentialStatement);
  336. databaseConnection.close(rs);
  337. databaseConnection.release();
  338. }
  339. return -1;
  340.  
  341. }
  342.  
  343. public static PlayerCredentials getPlayerCredentials(String playerName) {
  344. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "240");
  345. if (databaseConnection == null) {
  346. GameDatabase.getActionManager().reportUnavailableConnection();
  347. return null;
  348. }
  349.  
  350. ResultSet rs = null;
  351. PreparedStatement credentialStatement = databaseConnection.prepareStatement(credentialQuery);
  352. try {
  353. credentialStatement.setString(1, playerName);
  354. rs = credentialStatement.executeQuery();
  355. boolean found = rs.next();
  356. if (!found) {
  357. rs.close();
  358. credentialStatement = databaseConnection.prepareStatement(credentialOldQuery);
  359. credentialStatement.setString(1, playerName);
  360. rs = credentialStatement.executeQuery();
  361. found = rs.next();
  362. }
  363. if (found) {
  364. String connectedFrom = rs.getString(1);
  365. String regSerial = rs.getString(2);
  366. String playerMacAddress = rs.getString(3);
  367. return new PlayerCredentials(playerName, connectedFrom, regSerial, playerMacAddress);
  368. }
  369. } catch (SQLException e) {
  370. e.printStackTrace();
  371. } finally {
  372. databaseConnection.close(credentialStatement);
  373. databaseConnection.close(rs);
  374. databaseConnection.release();
  375. }
  376. return null;
  377. }
  378.  
  379. public static void comparePlayers(final Client c, final Player p, final String player, final String other) {
  380. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  381. @Override
  382. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  383. if (databaseConnection != null) {
  384. PreparedStatement preparedStatement = databaseConnection.prepareStatement("select `regSerial`, `playerMacAdress`, `connectedFrom`, `bankPin`, `dbid`, 'systemName' from clients where playerName = ? limit 1");
  385. try {
  386. preparedStatement.setString(1, other);
  387. } catch (SQLException e) {
  388. e.printStackTrace();
  389. }
  390. return preparedStatement;
  391. }
  392. return null;
  393. }
  394.  
  395. @Override
  396. public void future() {
  397. ResultSet rs = getResults();
  398.  
  399. if (p == null || c == null) {
  400. return;
  401. }
  402.  
  403. if (rs != null) {
  404. try {
  405. if (rs.next()) {
  406. /** Start **/
  407.  
  408. int ownershipPercent = 0;
  409. String regSerial = rs.getString(1);
  410. String macAdress = rs.getString(2);
  411. String connectedFrom = rs.getString(3);
  412. int bankPin = rs.getInt(4);
  413. final int databaseID = rs.getInt(5);
  414. String systemName = rs.getString(6);
  415.  
  416. boolean sameComputer = false;
  417. boolean sameIP = false;
  418. boolean sameClient = false;
  419. boolean sameSystem = false;
  420.  
  421. if (p.connectedFrom.equalsIgnoreCase(connectedFrom)) {
  422. ownershipPercent += 25;
  423. sameIP = true;
  424. }
  425.  
  426. if (p.playerMacAdress.equalsIgnoreCase(macAdress)) {
  427. ownershipPercent += 25;
  428. sameComputer = true;
  429. }
  430.  
  431. if (p.regSerial.equalsIgnoreCase(regSerial)) {
  432. ownershipPercent += 25;
  433. sameClient = true;
  434. }
  435. if (systemName != null && !systemName.isEmpty() && !systemName.equals("admin") && !systemName.equals("user")) {
  436. if (p.systemName.equalsIgnoreCase(systemName)) {
  437. ownershipPercent += 25;
  438. sameSystem = true;
  439. }
  440. }
  441. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Shallow ownership probability: " + ownershipPercent + "%");
  442. c.sendMessage("<img=4>@gre@Account details:");
  443. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account " + (sameComputer ? "was" : "@red@wasn't@gre@") + " created at same computer.");
  444. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account " + (sameIP ? "was" : "@red@wasn't@gre@") + " lastly logged in using same IP.");
  445. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account " + (sameClient ? "was" : "@red@wasn't@gre@") + " lastly logged in using same Client.");
  446. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account " + (sameSystem ? "was" : "@red@wasn't@gre@") + " lastly logged in using same System.");
  447. if (bankPin >= 0) {
  448. c.sendMessage("<img=4>@gre@Bank pin: " + bankPin);
  449. } else {
  450. c.sendMessage("<img=4>@gre@User has no pin.");
  451. }
  452.  
  453. c.sendMessage("<img=4>Checking login history...");
  454. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  455.  
  456. @Override
  457. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  458. if (databaseConnection != null) {
  459. PreparedStatement loginStatement = databaseConnection.prepareStatement("select `regSerial`, `macAdress`, `connectedFrom` from loginlogs where dbid = ? order by `date` desc limit 300");
  460. try {
  461. loginStatement.setInt(1, databaseID);
  462. } catch (SQLException e) {
  463. e.printStackTrace();
  464. }
  465. return loginStatement;
  466. }
  467. return null;
  468. }
  469.  
  470. @Override
  471. public void future() {
  472. ResultSet logResult = getResults();
  473. float ipLogs = 0;
  474. float computerLogs = 0;
  475. float clientLogs = 0;
  476. float totalLogs = 0;
  477. try {
  478. while (logResult.next()) {
  479. totalLogs++;
  480. String regSerial = logResult.getString(1);
  481. String macAdress = logResult.getString(2);
  482. String connectedFrom = logResult.getString(3);
  483. if (p.connectedFrom.equalsIgnoreCase(connectedFrom)) {
  484. ipLogs++;
  485. }
  486. if (p.playerMacAdress.equalsIgnoreCase(macAdress)) {
  487. computerLogs++;
  488. }
  489. if (p.regSerial.equalsIgnoreCase(regSerial)) {
  490. clientLogs++;
  491. }
  492. }
  493. } catch (SQLException e) {
  494. e.printStackTrace();
  495. }
  496.  
  497. int ipPercent = (int) ((ipLogs * 100f) / totalLogs);
  498. int computerPercent = (int) ((computerLogs * 100f) / totalLogs);
  499. int clientPercent = (int) ((clientLogs * 100f) / totalLogs);
  500. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account \"" + other + "\" " + " logged in " + computerPercent + "% of times using same computer as account \"" + player + "\"");
  501. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account \"" + other + "\" " + " logged in " + ipPercent + "% of times using same IP as account \"" + player + "\"");
  502. c.sendMessage("<img=4><col=" + 0x00ff00 + ">Account \"" + other + "\" " + " logged in " + clientPercent + "% of times using same Client as account \"" + player + "\"");
  503.  
  504. }
  505.  
  506. };
  507. Server.asyncDatabaseWorker.submitModel(requestModel);
  508. /** End **/
  509. } else {
  510. c.sendMessage("<img=4>Player not found...");
  511. }
  512. } catch (SQLException e) {
  513. e.printStackTrace();
  514. }
  515. }
  516. }
  517. };
  518. Server.asyncDatabaseWorker.submitModel(requestModel);
  519. }
  520.  
  521. public static ArrayList<String> searchTrades(Client c, String player1, String player2) {
  522. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  523.  
  524. @Override
  525. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  526. StringBuilder sb = new StringBuilder("?");
  527. if (player2 != null) {
  528. sb.append(", ?");
  529. }
  530.  
  531. String query = null;
  532. if (player2 != null) {
  533. query = "select sender, receiver, `date` from tradelogs where sender in(?, ?) && receiver in(?, ?) group by `date` order by `date` desc ;";
  534. } else {
  535. query = "select sender, receiver, `date` from tradelogs where sender in(?) || receiver in(?) group by `date` order by `date` desc ;";
  536. }
  537. if (databaseConnection != null) {
  538. PreparedStatement credentialStatement = databaseConnection.prepareStatement(query);
  539. try {
  540. if (player2 != null) {
  541. credentialStatement.setString(1, player1);
  542. credentialStatement.setString(2, player2);
  543. credentialStatement.setString(3, player1);
  544. credentialStatement.setString(4, player2);
  545. } else {
  546. credentialStatement.setString(1, player1);
  547. credentialStatement.setString(2, player1);
  548. }
  549. } catch (SQLException e) {
  550. e.printStackTrace();
  551. }
  552. return credentialStatement;
  553. }
  554. return null;
  555. }
  556.  
  557. @Override
  558. public void future() {
  559. ResultSet rs = getResults();
  560.  
  561. try {
  562. int index = 0;
  563. while (rs.next()) {
  564. String sender = rs.getString(1);
  565. String receiver = rs.getString(2);
  566. Timestamp date = rs.getTimestamp(3);
  567. InterfaceHandler.setComponentText(c, 19, 3, index++, "\'" + Misc.capitalize(sender) + "' and '" + Misc.capitalize(receiver) + "\'");
  568. InterfaceHandler.setComponentText(c, 19, 3, index++, date.toString());
  569. if (index > 380)
  570. break;
  571. System.out.println("Sender: " + sender + ", Receiver: " + receiver + ", Date: " + date);
  572. }
  573. InterfaceHandler.setComponentText(c, 19, 2, "Trade History");
  574. int size = (index * 15) + 10;
  575. InterfaceHandler.setScrollBarSize(c, 19, 3, size + 5, size > 276 ? 276 : size + 5);
  576. InterfaceHandler.openScreenInterface(c, 19);
  577. // c.getPA().openOverlayInterface(45450, 3321);
  578. } catch (SQLException e) {
  579. c.sendMessage("Couldn't view trade.");
  580. }
  581. }
  582. };
  583.  
  584. Server.asyncDatabaseWorker.submitModel(requestModel);
  585. return null;
  586. }
  587.  
  588. public static void displayTrade(final Client c, final String date) {
  589. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  590.  
  591. @Override
  592. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  593. if (databaseConnection != null) {
  594. PreparedStatement credentialStatement = databaseConnection.prepareStatement("select sender, itemID, itemAmount from tradelogs where `date` = ?");
  595. try {
  596. credentialStatement.setString(1, date);
  597. } catch (SQLException e) {
  598. e.printStackTrace();
  599. }
  600. return credentialStatement;
  601. }
  602. return null;
  603. }
  604.  
  605. @Override
  606. public void future() {
  607. ResultSet rs = getResults();
  608. String playerOne = null;
  609. String playerTwo = null;
  610. ArrayList<GameItem> playerOneItems = new ArrayList<GameItem>();
  611. ArrayList<GameItem> playerTwoItems = new ArrayList<GameItem>();
  612.  
  613. try {
  614. while (rs.next()) {
  615. String sender = rs.getString(1);
  616. int itemID = rs.getInt(2);
  617. int itemAmount = rs.getInt(3);
  618.  
  619. if (playerOne == null) {
  620. playerOne = sender;
  621. } else if (!playerOne.equalsIgnoreCase(sender)) {
  622. playerTwo = sender;
  623. }
  624.  
  625. if (sender.equals(playerOne)) {
  626. playerOneItems.add(new GameItem(itemID, itemAmount));
  627. } else {
  628. playerTwoItems.add(new GameItem(itemID, itemAmount));
  629. }
  630. }
  631. StreamHandler.sendFrame126(c, "-", 45459);
  632. StreamHandler.sendFrame126(c, "-", 45460);
  633. StreamHandler.resetTItems(c, playerOneItems, 3415);
  634. StreamHandler.resetTItems(c, playerTwoItems, 3416);
  635. StreamHandler.sendFrame126(c, "Trade between " + playerOne + " and " + playerTwo, 45458);
  636. c.getPA().openOverlayInterface(45450, 3321);
  637. } catch (SQLException e) {
  638. c.sendMessage("Couldn't view trade.");
  639. }
  640. }
  641. };
  642. Server.asyncDatabaseWorker.submitModel(requestModel);
  643. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "540");
  644. if (databaseConnection == null) {
  645. GameDatabase.getActionManager().reportUnavailableConnection();
  646. return;
  647. }
  648.  
  649. }
  650.  
  651. public static class PlayerCredentials {
  652.  
  653. private final String playerName;
  654. private final String connectedFrom;
  655. private final String regSerial;
  656. private final String playerMacAddress;
  657.  
  658. /**
  659. * @param connectedFrom
  660. * : Network address used last time.
  661. * @param regSerial
  662. * : Serial Used last time.
  663. * @param playerMacAddress
  664. * : Mac Address that registered this account.
  665. */
  666. public PlayerCredentials(String playerName, String connectedFrom, String regSerial, String playerMacAddress) {
  667. this.playerName = playerName;
  668. this.connectedFrom = connectedFrom;
  669. this.regSerial = regSerial;
  670. this.playerMacAddress = playerMacAddress;
  671. }
  672.  
  673. public String getConnectedFrom() {
  674. return connectedFrom;
  675. }
  676.  
  677. public String getRegSerial() {
  678. return regSerial;
  679. }
  680.  
  681. public String getPlayerMacAddress() {
  682. return playerMacAddress;
  683. }
  684.  
  685. @Override
  686. public String toString() {
  687. return "PlayerCredentials [connectedFrom=" + connectedFrom + ", regSerial=" + regSerial + ", playerMacAddress=" + playerMacAddress + "]";
  688. }
  689.  
  690. public String getPlayerName() {
  691. return playerName;
  692. }
  693.  
  694. }
  695.  
  696. public static void randomizeAccountPassword(final Client c, final String playerName) {
  697. final StringBuffer sb = new StringBuffer();
  698. for (int i = 0; i < 4; i++) {
  699. sb.append(Misc.random(9));
  700. }
  701. RequestModel requestModel = new RequestModel(c, QueryType.UPDATE) {
  702.  
  703. @Override
  704. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  705. if (databaseConnection != null) {
  706. PreparedStatement loginStatement = databaseConnection.prepareStatement("update clients set encryptedPass = ? where playerName = ?");
  707. try {
  708. loginStatement.setString(1, BCrypt.hashpw(Misc.saltPass(sb.toString()), BCrypt.gensalt(Config.SALT_STRENGTH)));
  709. loginStatement.setString(2, playerName);
  710. } catch (SQLException e) {
  711. e.printStackTrace();
  712. }
  713. return loginStatement;
  714. }
  715. return null;
  716. }
  717.  
  718. @Override
  719. public void future() {
  720. int updatedRows = getUpdatedRows();
  721. if (updatedRows > 0) {
  722. c.sendMessage("<img=4>@gre@Account " + Misc.capitalizeFirstLetter(playerName) + " password: " + sb.toString());
  723. } else {
  724. c.sendMessage("Couldn't change account password.");
  725. }
  726. }
  727. };
  728. Server.asyncDatabaseWorker.submitModel(requestModel);
  729. }
  730.  
  731. static {
  732. prepareStatements();
  733. }
  734.  
  735. public static void clearAccount(final Client c, final String playerName) {
  736. RequestModel requestModel = new RequestModel(c, QueryType.UPDATE) {
  737.  
  738. @Override
  739. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  740. if (databaseConnection != null) {
  741. PreparedStatement clearStatement = databaseConnection.prepareStatement("update clients set playerEquipment = '-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:-1:0:', playerItems = '', bankItems = '' where playerName = ? limit 1");
  742. try {
  743. clearStatement.clearParameters();
  744. clearStatement.setString(1, playerName);
  745. } catch (SQLException e) {
  746. e.printStackTrace();
  747. }
  748. return clearStatement;
  749. }
  750. return null;
  751. }
  752.  
  753. @Override
  754. public void future() {
  755. if (getUpdatedRows() > 0) {
  756. c.sendMessage("<img=4>Deleted all items from off-line account: \"" + playerName + "\"");
  757. } else {
  758. c.sendMessage("<img=4>Couldn't delete player items.");
  759. }
  760. }
  761. };
  762. Server.asyncDatabaseWorker.submitModel(requestModel);
  763. }
  764.  
  765. public static void displayOtherItems(final Client c, final String playerName) {
  766.  
  767. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  768.  
  769. @Override
  770. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  771. if (databaseConnection != null) {
  772. PreparedStatement selectStatement = databaseConnection.prepareStatement("select `playerItems`, `playerBank` from clients where playerName = ? limit 1");
  773. try {
  774. selectStatement.setString(1, playerName);
  775. } catch (SQLException e) {
  776. e.printStackTrace();
  777. }
  778. return selectStatement;
  779. }
  780. return null;
  781. }
  782.  
  783. @Override
  784. public void future() {
  785. ResultSet rs = getResults();
  786. try {
  787. boolean found = rs.next();
  788. if (found) {
  789. String playerItemsString = rs.getString(1);
  790. String bankDocument = rs.getString(2);
  791.  
  792. int playerItems[] = new int[28];
  793. int playerItemsN[] = new int[28];
  794. String[] itemsArray = playerItemsString.split(":");
  795. for (int id = 0; id < itemsArray.length / 3; id++) {
  796. int n = Integer.valueOf(itemsArray[id * 3]).intValue();
  797. int itemID = Integer.valueOf(itemsArray[id * 3 + 1]).intValue();
  798. int itemAmount = Integer.valueOf(itemsArray[id * 3 + 2]).intValue();
  799. playerItems[n] = itemID;
  800. playerItemsN[n] = itemAmount;
  801. }
  802. BankWrapper bankWrapper = new Gson().fromJson(bankDocument, BankWrapper.class);
  803. if (bankWrapper != null && bankWrapper.getItems() != null) {
  804. c.getBank().renderBank(bankWrapper);
  805. }
  806. List<GameItem> gameItems = new ArrayList<GameItem>();
  807. for (int i = 0; i < playerItems.length; i++) {
  808. int itemID = playerItems[i] - 1;
  809. int amount = playerItemsN[i];
  810. gameItems.add(new GameItem(itemID, amount));
  811. }
  812. InterfaceHandler.resetInventoryItems(c, BankConstants.INVENTORY_ID, 0, gameItems);
  813. playerItems = null;
  814. playerItemsN = null;
  815. } else {
  816. c.sendMessage("<img=4>Player not found!");
  817. }
  818. } catch (Exception e) {
  819. c.sendMessage("<img=4>Error checking player bank.");
  820. }
  821. }
  822. };
  823. Server.asyncDatabaseWorker.submitModel(requestModel);
  824. }
  825.  
  826. public static void displayOtherItemsOld(final Client c, final String playerName) {
  827.  
  828. RequestModel requestModel = new RequestModel(c, QueryType.SELECT) {
  829.  
  830. @Override
  831. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  832. if (databaseConnection != null) {
  833. PreparedStatement selectStatement = databaseConnection.prepareStatement("select `playerItems`, `bankItems` from clients_old where playerName = ? limit 1");
  834. try {
  835. selectStatement.setString(1, playerName);
  836. } catch (SQLException e) {
  837. e.printStackTrace();
  838. }
  839. return selectStatement;
  840. }
  841. return null;
  842. }
  843.  
  844. @Override
  845. public void future() {
  846. ResultSet rs = getResults();
  847. try {
  848. boolean found = rs.next();
  849. if (found) {
  850. String playerItemsString = rs.getString(1);
  851. String bankItemsString = rs.getString(2);
  852.  
  853. int playerItems[] = new int[28];
  854. int playerItemsN[] = new int[28];
  855. int bankItems[] = new int[Config.BANK_SIZE + 28 + 20];
  856. int bankItemsN[] = new int[Config.BANK_SIZE + 28 + 20];
  857.  
  858. String[] itemsArray = playerItemsString.split(":");
  859. for (int id = 0; id < itemsArray.length / 3; id++) {
  860. int n = Integer.valueOf(itemsArray[id * 3]).intValue();
  861. int itemID = Integer.valueOf(itemsArray[id * 3 + 1]).intValue();
  862. int itemAmount = Integer.valueOf(itemsArray[id * 3 + 2]).intValue();
  863. playerItems[n] = itemID;
  864. playerItemsN[n] = itemAmount;
  865. }
  866.  
  867. String[] banksArray = bankItemsString.split(":");
  868. int len = banksArray.length;
  869. for (int id = 0; id < banksArray.length / 3; id++) {
  870. if (len <= id * 3 || len <= (id * 3 + 1) || len <= (id * 3 + 2))
  871. continue;
  872. int n = Integer.valueOf(banksArray[id * 3]).intValue();
  873. int itemID = Integer.valueOf(banksArray[id * 3 + 1]).intValue();
  874. int itemAmount = Integer.valueOf(banksArray[id * 3 + 2]).intValue();
  875. bankItems[n] = itemID;
  876. bankItemsN[n] = itemAmount;
  877. }
  878. StreamHandler.displayInventory(c, 5064, playerItems, playerItemsN);
  879. StreamHandler.openBank(c);
  880. bankItems = null;
  881. bankItemsN = null;
  882. playerItems = null;
  883. playerItemsN = null;
  884. } else {
  885. c.sendMessage("<img=4>Player not found!");
  886. }
  887. } catch (Exception e) {
  888. c.sendMessage("<img=4>Error checking player bank.");
  889. }
  890. }
  891. };
  892. Server.asyncDatabaseWorker.submitModel(requestModel);
  893. }
  894.  
  895. public static void copyFromHighscores(Client p) {
  896.  
  897. RequestModel requestModel = new RequestModel(p, QueryType.SELECT, GameDatabase.getWebsiteDatabaseManager()) {
  898.  
  899. @Override
  900. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  901. if (databaseConnection != null) {
  902. PreparedStatement selectStatement = databaseConnection.prepareStatement("select playerID, skillID, skillLevel, skillExperience from highscores where playerID = (select playerID from overall where playerName = ? order by playerID asc limit 1);");
  903. try {
  904. selectStatement.setString(1, p.playerName);
  905. } catch (SQLException e) {
  906. e.printStackTrace();
  907. }
  908. return selectStatement;
  909. }
  910. return null;
  911. }
  912.  
  913. @Override
  914. public void future() {
  915. ResultSet rs = getResults();
  916. try {
  917. while (rs.next()) {
  918. int skillID = rs.getInt(1);
  919. int level = rs.getInt(2);
  920. int exp = rs.getInt(3);
  921. p.playerLevel[skillID] = level;
  922. p.playerXP[skillID] = exp;
  923. p.getPA().refreshSkill(skillID);
  924. }
  925. p.sendMessage("Your stats were restored successfully.");
  926. } catch (Exception e) {
  927. p.sendMessage("<img=4>Error checking player rank.");
  928. }
  929. }
  930. };
  931. Server.asyncDatabaseWorker.submitModel(requestModel);
  932. }
  933.  
  934. public static boolean isDevelopementSupporter(String playerName, String regSerial) {
  935. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "932");
  936. if (databaseConnection == null) {
  937. GameDatabase.getActionManager().reportUnavailableConnection();
  938. return false;
  939. }
  940.  
  941. ResultSet rs = null;
  942. PreparedStatement credentialStatement = databaseConnection.prepareStatement("select count(*) from supportgroup where playerName = ?;");
  943.  
  944. try {
  945. credentialStatement.setString(1, playerName);
  946. // credentialStatement.setString(2, regSerial);
  947. rs = credentialStatement.executeQuery();
  948. if (rs.next()) {
  949. return rs.getInt(1) >= 1;
  950. }
  951. } catch (SQLException e) {
  952. e.printStackTrace();
  953. } finally {
  954. databaseConnection.close(credentialStatement);
  955. databaseConnection.close(rs);
  956. databaseConnection.release();
  957. }
  958. return false;
  959. }
  960.  
  961. public static ArrayList<PlayerPunishment> getPunishments(PlayerCredentials playerCredentials, PunishmentType punishmentType) {
  962. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getPriorityConnection(1500, null);
  963. if (databaseConnection == null) {
  964. GameDatabase.getActionManager().reportUnavailableConnection();
  965. return null;
  966. }
  967. if (playerCredentials == null) {
  968. return null;
  969. }
  970. ArrayList<PlayerPunishment> playerBans = new ArrayList<PlayerPunishment>();
  971. String playerName = playerCredentials.getPlayerName();
  972. String macAddress = playerCredentials.getPlayerMacAddress();
  973. String hostAddress = playerCredentials.getConnectedFrom();
  974. String serial = playerCredentials.getRegSerial();
  975.  
  976. String query = "select `index`, playerName, agent, expireDate, duration, type, reason, punishment from punishment where ";
  977.  
  978. query += "(";
  979. if (punishmentType != PunishmentType.JAIL) {
  980. boolean searchMacAddress = !PunishHandler.ignoreMacAdress(macAddress);
  981. boolean searchHostAddress = !PunishHandler.ignoreHost(hostAddress);
  982. boolean searchSerial = !PunishHandler.ignoreSerial(hostAddress);
  983. if (searchMacAddress || searchHostAddress || searchSerial) {
  984. if (searchMacAddress) {
  985. query += "macAddress = '" + macAddress + "' or ";
  986. }
  987. if (searchHostAddress) {
  988. query += "hostAddress = '" + hostAddress + "' or ";
  989. }
  990. if (searchSerial) {
  991. query += "serial = '" + serial + "' or ";
  992. }
  993. }
  994. }
  995. if (punishmentType == null) {
  996. query += "playerName = '" + playerName + "');";
  997. } else {
  998. query += "playerName = '" + playerName + "') and punishment = '" + punishmentType.name() + "';";
  999. }
  1000. ResultSet rs = null;
  1001. try {
  1002. rs = databaseConnection.executeQuery(query);
  1003.  
  1004. while (rs.next()) {
  1005. int index = rs.getInt(1);
  1006. String name = rs.getString(2);
  1007. String agent = rs.getString(3);
  1008. long expireDate = rs.getLong(4);
  1009. String duration = rs.getString(5);
  1010. String type = rs.getString(6);
  1011. String reason = rs.getString(7);
  1012. PunishmentType punishType = PunishmentType.valueOf(rs.getString(8));
  1013. PlayerPunishment playerBan = new PlayerPunishment(index, name, agent, expireDate, duration, type, reason, macAddress, hostAddress, serial, punishType);
  1014. playerBans.add(playerBan);
  1015. }
  1016. } catch (Exception ex) {
  1017. ex.printStackTrace();
  1018. } finally {
  1019. databaseConnection.close(rs);
  1020. databaseConnection.release();
  1021. }
  1022. return playerBans;
  1023. }
  1024.  
  1025. public static boolean addPunishment(PlayerPunishment playerPunishment) {
  1026. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1147");
  1027. if (databaseConnection == null) {
  1028. GameDatabase.getActionManager().reportUnavailableConnection();
  1029. return false;
  1030. }
  1031.  
  1032. PreparedStatement insertStatement = databaseConnection.prepareStatement("insert into punishment (playerName, agent, expireDate, duration, type, reason, macAddress, hostAddress, serial, punishment) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  1033. try {
  1034. insertStatement.setString(1, playerPunishment.getPlayerName());
  1035. insertStatement.setString(2, playerPunishment.getAgent());
  1036. insertStatement.setLong(3, playerPunishment.getExpireDate());
  1037. insertStatement.setString(4, playerPunishment.getDuration());
  1038. insertStatement.setString(5, playerPunishment.getType());
  1039. insertStatement.setString(6, playerPunishment.getReason());
  1040. insertStatement.setString(7, playerPunishment.getMacAddress());
  1041. insertStatement.setString(8, playerPunishment.getHostAddress());
  1042. insertStatement.setString(9, playerPunishment.getSerial());
  1043. insertStatement.setString(10, playerPunishment.getPunishmentType().name());
  1044. return insertStatement.executeUpdate() > 0;
  1045. } catch (Exception ex) {
  1046. ex.printStackTrace();
  1047. } finally {
  1048. databaseConnection.close(insertStatement);
  1049. databaseConnection.release();
  1050. }
  1051. return false;
  1052.  
  1053. }
  1054.  
  1055. public static int removePunishment(int index) {
  1056. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1084");
  1057. if (databaseConnection == null) {
  1058. GameDatabase.getActionManager().reportUnavailableConnection();
  1059. return 0;
  1060. }
  1061.  
  1062. PreparedStatement deletestatement = databaseConnection.prepareStatement("delete from punishment where `index` = ?;");
  1063. int deletedPunishments = 0;
  1064. try {
  1065. deletestatement.setInt(1, index);
  1066. deletedPunishments = deletestatement.executeUpdate();
  1067. } catch (Exception ex) {
  1068. ex.printStackTrace();
  1069. } finally {
  1070. databaseConnection.close(deletestatement);
  1071. databaseConnection.release();
  1072. }
  1073. return deletedPunishments;
  1074. }
  1075.  
  1076. public static int removePunishments(String playerName, PunishmentType punishmentType) {
  1077. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1105");
  1078. if (databaseConnection == null) {
  1079. GameDatabase.getActionManager().reportUnavailableConnection();
  1080. return 0;
  1081. }
  1082.  
  1083. PreparedStatement deletestatement = databaseConnection.prepareStatement("delete from punishment where playerName = ? and punishment = ?;");
  1084. int deletedPunishments = 0;
  1085. try {
  1086. deletestatement.setString(1, playerName);
  1087. deletestatement.setString(2, punishmentType.name());
  1088. deletedPunishments = deletestatement.executeUpdate();
  1089. } catch (Exception ex) {
  1090. ex.printStackTrace();
  1091. } finally {
  1092. databaseConnection.close(deletestatement);
  1093. databaseConnection.release();
  1094. }
  1095. return deletedPunishments;
  1096. }
  1097.  
  1098. public static PlayerPunishment getPunishment(int index) {
  1099. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1217");
  1100. if (databaseConnection == null) {
  1101. GameDatabase.getActionManager().reportUnavailableConnection();
  1102. return null;
  1103. }
  1104. PreparedStatement searchStatement = databaseConnection.prepareStatement("select playerName, agent, expireDate, duration, type, reason, punishment from punishment where `index` = ?;");
  1105.  
  1106. ResultSet rs = null;
  1107. try {
  1108. searchStatement.setInt(1, index);
  1109. rs = searchStatement.executeQuery();
  1110.  
  1111. while (rs.next()) {
  1112. String name = rs.getString(1);
  1113. String agent = rs.getString(2);
  1114. long expireDate = rs.getLong(3);
  1115. String duration = rs.getString(4);
  1116. String type = rs.getString(5);
  1117. String reason = rs.getString(6);
  1118. PunishmentType punishType = PunishmentType.valueOf(rs.getString(7));
  1119. PlayerPunishment playerBan = new PlayerPunishment(index, name, agent, expireDate, duration, type, reason, null, null, null, punishType);
  1120. return playerBan;
  1121. }
  1122. } catch (Exception ex) {
  1123. ex.printStackTrace();
  1124. } finally {
  1125. databaseConnection.close(rs);
  1126. databaseConnection.close(searchStatement);
  1127. databaseConnection.release();
  1128. }
  1129. return null;
  1130. }
  1131.  
  1132. public static String addMiddleman(String playerName) {
  1133. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1254");
  1134. if (databaseConnection == null) {
  1135. GameDatabase.getActionManager().reportUnavailableConnection();
  1136. return "Database error";
  1137. }
  1138. int playerID = getPlayerID(playerName);
  1139. playerName = Misc.capitalizeFirstLetter(playerName);
  1140. PreparedStatement insertStatement = null;
  1141. try {
  1142. if (playerID < 0) {
  1143. return "<img=4>The player '" + playerName + "' was not found.";
  1144. }
  1145. insertStatement = databaseConnection.prepareStatement("insert into middleman(playerID) values(?);");
  1146. insertStatement.setInt(1, playerID);
  1147. int inserted = insertStatement.executeUpdate();
  1148.  
  1149. return inserted > 0 ? "<img=4>" + playerName + " was successfully added to middlemen list." : "<img=4>" + playerName + " couldn't be inserted to middleman list.";
  1150. } catch (SQLException e) {
  1151. if (e.getErrorCode() == 1062) {
  1152. return "<img=4>" + playerName + " is already in the middlemen list";
  1153. } else {
  1154. e.printStackTrace();
  1155. return "<img=4>Unknown error: " + e.getErrorCode();
  1156. }
  1157.  
  1158. } finally {
  1159. databaseConnection.close(insertStatement);
  1160. databaseConnection.release();
  1161. }
  1162. }
  1163.  
  1164. public static String removeMiddleman(String playerName) {
  1165. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1286");
  1166. if (databaseConnection == null) {
  1167. GameDatabase.getActionManager().reportUnavailableConnection();
  1168. return "<img=4>Database error";
  1169. }
  1170. int playerID = getPlayerID(playerName);
  1171. playerName = Misc.capitalizeFirstLetter(playerName);
  1172. PreparedStatement removeStatement = null;
  1173. try {
  1174. if (playerID < 0) {
  1175. return "<img=4>The player '" + playerName + "' was not found.";
  1176. }
  1177. removeStatement = databaseConnection.prepareStatement("delete from middleman where playerID = ?;");
  1178. removeStatement.setInt(1, playerID);
  1179. int inserted = removeStatement.executeUpdate();
  1180.  
  1181. return inserted > 0 ? "<img=4>" + playerName + " was successfully removed from middlemen list." : "<img=4>" + playerName + " couldn't be removed from middleman list.";
  1182. } catch (SQLException e) {
  1183. e.printStackTrace();
  1184. return "<img=4>Unknown error: " + e.getErrorCode();
  1185. } finally {
  1186. databaseConnection.close(removeStatement);
  1187. databaseConnection.release();
  1188. }
  1189. }
  1190.  
  1191. public static void checkMiddlemans(Client p) {
  1192. RequestModel requestModel = new RequestModel(p, QueryType.SELECT, GameDatabase.getActionManager()) {
  1193.  
  1194. @Override
  1195. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  1196. if (databaseConnection != null) {
  1197. return databaseConnection.prepareStatement("select playerID, playerName from middleman left join clients on playerID = dbid;");
  1198. }
  1199. return null;
  1200. }
  1201.  
  1202. @Override
  1203. public void future() {
  1204. ResultSet rs = getResults();
  1205. ArrayList<String> onlineMiddlemen = new ArrayList<String>();
  1206. ArrayList<String> offlineMiddlemen = new ArrayList<String>();
  1207. try {
  1208. while (rs.next()) {
  1209. int playerID = rs.getInt(1);
  1210. String playerName = rs.getString(2);
  1211. boolean online = PlayerHandler.getClient(playerID) != null;
  1212. if (online) {
  1213. onlineMiddlemen.add(Misc.capitalizeFirstLetter(playerName) + " - @gre@Online");
  1214. } else {
  1215. offlineMiddlemen.add(Misc.capitalizeFirstLetter(playerName) + " - @red@Offline");
  1216. }
  1217. }
  1218. } catch (SQLException e) {
  1219. e.printStackTrace();
  1220. }
  1221. ArrayList<String> middlemenList = new ArrayList<String>();
  1222. middlemenList.addAll(onlineMiddlemen);
  1223. middlemenList.addAll(offlineMiddlemen);
  1224. TextScroll.displayText(p, "Official Middlemen", middlemenList);
  1225. }
  1226. };
  1227. Server.asyncDatabaseWorker.submitModel(requestModel);
  1228. }
  1229.  
  1230. public static void checkPremiumExtract(Client p, int playerID, boolean staffView) {
  1231.  
  1232. RequestModel requestModel = new RequestModel(p, QueryType.SELECT, GameDatabase.getActionManager()) {
  1233.  
  1234. @Override
  1235. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  1236. if (databaseConnection != null) {
  1237. try {
  1238. PreparedStatement statement = databaseConnection.prepareStatement("select extractType, source, value, itemID, itemAmount, balance, dateTime, host from premiumextract where playerID = ? order by dateTime desc;");
  1239. statement.setInt(1, playerID);
  1240. return statement;
  1241. } catch (SQLException e) {
  1242. e.printStackTrace();
  1243. }
  1244. }
  1245. return null;
  1246. }
  1247.  
  1248. @Override
  1249. public void future() {
  1250. ResultSet rs = getResults();
  1251. ArrayList<String> extract = new ArrayList<String>();
  1252. try {
  1253. while (rs.next()) {
  1254. ExtractType extractType = ExtractType.valueOf(rs.getString(1));
  1255. String source = rs.getString(2);
  1256. int value = rs.getInt(3);
  1257. int itemID = rs.getInt(4);
  1258. int itemAmount = rs.getInt(5);
  1259. int balance = rs.getInt(6);
  1260. Timestamp dateTime = rs.getTimestamp(7);
  1261. String host = rs.getString(8);
  1262.  
  1263. if (extractType == ExtractType.OUTCOME) {
  1264. extract.add("@red@-----------------" + Misc.formatTimeStamp(dateTime) + " GMT -----------------");
  1265. extract.add(source);
  1266. if (itemID > 0)
  1267. extract.add(Misc.format(itemAmount) + " x " + ItemHandler.getItemName(itemID));
  1268. extract.add("Balance: <col=0xdfdfdf>" + Misc.format(balance) + "</col> point(s) (<col=0xFF0000>-" + Misc.format(value) + "</col>)");
  1269. if (staffView) {
  1270. extract.add("Host: @whi@" + host);
  1271. }
  1272. extract.add("");
  1273. } else if (extractType == ExtractType.INCOME) {
  1274. extract.add("@gr3@-----------------" + Misc.formatTimeStamp(dateTime) + " GMT -----------------");
  1275. extract.add(source);
  1276. extract.add("Balance: <col=0xdfdfdf>" + Misc.format(balance) + "</col> point(s) (<col=0x00FF00>+" + Misc.format(value) + "</col>)");
  1277. if (staffView) {
  1278. extract.add("Host: @whi@" + host);
  1279. }
  1280. extract.add("");
  1281. }
  1282. }
  1283.  
  1284. } catch (SQLException e) {
  1285. e.printStackTrace();
  1286. }
  1287. if (extract.size() <= 0) {
  1288. if (!staffView) {
  1289. DialogueManager.sendChat(p, new DialogueChat("You don't have any history of premium points transactions.").setStatementDialogue());
  1290. } else {
  1291. p.sendMessage("This player doesn't have any premium points transaction.");
  1292. }
  1293. } else {
  1294. TextScroll.displayText(p, "Premium points history", extract);
  1295. }
  1296. }
  1297. };
  1298. Server.asyncDatabaseWorker.submitModel(requestModel);
  1299. }
  1300.  
  1301. public static String getPlayerName(int playerID) {
  1302.  
  1303. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1424");
  1304. if (databaseConnection == null) {
  1305. GameDatabase.getActionManager().reportUnavailableConnection();
  1306. return null;
  1307. }
  1308.  
  1309. ResultSet rs = null;
  1310. PreparedStatement credentialStatement = null;
  1311. try {
  1312. credentialStatement = databaseConnection.prepareStatement("select playerName from clients where dbid = ?;");
  1313. credentialStatement.setInt(1, playerID);
  1314. rs = credentialStatement.executeQuery();
  1315. if (rs.next()) {
  1316. String playerName = rs.getString(1);
  1317. return playerName;
  1318. }
  1319. } catch (SQLException e) {
  1320. e.printStackTrace();
  1321. } finally {
  1322. databaseConnection.close(credentialStatement);
  1323. databaseConnection.close(rs);
  1324. databaseConnection.release();
  1325. }
  1326. return null;
  1327. }
  1328.  
  1329. public static Map<Integer, String> getPlayesNames(int... playersIDs) {
  1330.  
  1331. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1451");
  1332. if (databaseConnection == null) {
  1333. GameDatabase.getActionManager().reportUnavailableConnection();
  1334. return null;
  1335. }
  1336.  
  1337. ResultSet rs = null;
  1338. PreparedStatement credentialStatement = null;
  1339. String parameter = Misc.buildArrayString(playersIDs, true);
  1340. try {
  1341. if (parameter.trim().isEmpty()) {
  1342. return null;
  1343. }
  1344. Map<Integer, String> nameMap = new HashMap<Integer, String>();
  1345.  
  1346. credentialStatement = databaseConnection.prepareStatement("SELECT dbid, playerName FROM clients WHERE dbid IN(" + parameter + ");");
  1347. rs = credentialStatement.executeQuery();
  1348. while (rs.next()) {
  1349. int playerID = rs.getInt(1);
  1350. String playerName = rs.getString(2);
  1351. nameMap.put(playerID, playerName);
  1352. }
  1353. return nameMap;
  1354. } catch (SQLException e) {
  1355. e.printStackTrace();
  1356. } finally {
  1357. databaseConnection.close(credentialStatement);
  1358. databaseConnection.close(rs);
  1359. databaseConnection.release();
  1360. }
  1361. return null;
  1362. }
  1363.  
  1364. public static void getAccountEmail(Client c, String playerName) {
  1365. RequestModel requestModel = new RequestModel(c, QueryType.SELECT, GameDatabase.getActionManager()) {
  1366.  
  1367. @Override
  1368. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  1369. if (databaseConnection != null) {
  1370. try {
  1371. PreparedStatement statement = databaseConnection.prepareStatement("select playerEmail from clients where playerName = ?;");
  1372. statement.setString(1, playerName);
  1373. return statement;
  1374. } catch (SQLException e) {
  1375. e.printStackTrace();
  1376. }
  1377. }
  1378. return null;
  1379. }
  1380.  
  1381. @Override
  1382. public void future() {
  1383. ResultSet rs = getResults();
  1384. try {
  1385. if (rs.next()) {
  1386. String email = rs.getString(1);
  1387. if (email != null) {
  1388. c.sendMessage("<img=4>@gr3@The '" + playerName + "' email is: '" + email + "'");
  1389. } else {
  1390. c.sendMessage("<img=4>@red@There's no e-mail registered on that account.");
  1391. }
  1392. } else {
  1393. c.sendMessage("<img=4>Record not found.");
  1394. }
  1395. } catch (SQLException e) {
  1396. e.printStackTrace();
  1397. }
  1398. }
  1399. };
  1400. Server.asyncDatabaseWorker.submitModel(requestModel);
  1401. }
  1402.  
  1403. public static void searchPasswordHistory(Client c, String playerName, String password) {
  1404. RequestModel requestModel = new RequestModel(c, QueryType.SELECT, GameDatabase.getActionManager()) {
  1405.  
  1406. @Override
  1407. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  1408. if (databaseConnection != null) {
  1409. try {
  1410. PreparedStatement statement = databaseConnection.prepareStatement("select count(*) from passchangelogs where playerName = ? and oldpassword = ?;");
  1411. statement.setString(1, playerName);
  1412. statement.setString(2, password);
  1413. return statement;
  1414. } catch (SQLException e) {
  1415. e.printStackTrace();
  1416. }
  1417. }
  1418. return null;
  1419. }
  1420.  
  1421. @Override
  1422. public void future() {
  1423. ResultSet rs = getResults();
  1424. try {
  1425. while (rs.next()) {
  1426. int foundResults = rs.getInt(1);
  1427. if (foundResults > 0) {
  1428. c.sendMessage("<img=4>@gr3@Identified this password on the account history.");
  1429. } else {
  1430. c.sendMessage("<img=4>@red@This password was not found on the account history.");
  1431. }
  1432. }
  1433. } catch (SQLException e) {
  1434. e.printStackTrace();
  1435. }
  1436. }
  1437. };
  1438. Server.asyncDatabaseWorker.submitModel(requestModel);
  1439. }
  1440.  
  1441. public static String addDevSupporter(Client c, String playerName, String skype, int GMT) {
  1442. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1524");
  1443. if (databaseConnection == null) {
  1444. GameDatabase.getActionManager().reportUnavailableConnection();
  1445. return "Database error";
  1446. }
  1447. PreparedStatement insertStatement = null;
  1448. try {
  1449. insertStatement = databaseConnection.prepareStatement("insert into supportGroup (playerName, skype, gmt) values (?, ?, ?);");
  1450. insertStatement.setString(1, playerName);
  1451. insertStatement.setString(2, skype);
  1452. insertStatement.setInt(3, GMT);
  1453. int inserted = insertStatement.executeUpdate();
  1454.  
  1455. return inserted > 0 ? "<img=4>" + playerName + " was successfully added to supporters list." : "<img=4>" + playerName + " couldn't be inserted to supporters list.";
  1456. } catch (SQLException e) {
  1457. if (e.getErrorCode() == 1062) {
  1458. return "<img=4>" + playerName + " is already in the supporters list";
  1459. } else {
  1460. e.printStackTrace();
  1461. return "<img=4>Unknown error: " + e.getErrorCode();
  1462. }
  1463. }
  1464. }
  1465. public static void addVoteRecord(Client player, int points) {
  1466. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1528");
  1467. if (databaseConnection == null) {
  1468. GameDatabase.getActionManager().reportUnavailableConnection();
  1469. return;
  1470. }
  1471. int playerID = player.accountID;
  1472. String playerName = player.getFormattedName();
  1473. PreparedStatement insertStatement = null;
  1474. try {
  1475. insertStatement = databaseConnection.prepareStatement("insert into votes_record (playerID, playerName, connectedFrom, serial, points) VALUES(?, ?, ?, ?, ?);");
  1476. insertStatement.setInt(1, playerID);
  1477. insertStatement.setString(2, playerName);
  1478. insertStatement.setString(3, player.connectedFrom);
  1479. insertStatement.setString(4, player.regSerial);
  1480. insertStatement.setInt(5, points);
  1481.  
  1482. insertStatement.executeUpdate();
  1483. VoteContest.update();
  1484.  
  1485. } catch (SQLException e) {
  1486. e.printStackTrace();
  1487. } finally {
  1488. databaseConnection.close(insertStatement);
  1489. databaseConnection.release();
  1490. }
  1491. }
  1492.  
  1493. public static ArrayList<ContestWinners> getTopVoters(int maxPosition) {
  1494. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1558");
  1495. if (databaseConnection == null) {
  1496. GameDatabase.getActionManager().reportUnavailableConnection();
  1497. return null;
  1498. }
  1499. ArrayList<ContestWinners> topVoters = new ArrayList<ContestWinners>();
  1500. PreparedStatement searchStatement = null;
  1501. ResultSet rs = null;
  1502. try {
  1503. searchStatement = databaseConnection.prepareStatement("select vr.playerID, vr.playerName, sum(points) totalPoints, c.voteStreaks from votes_record vr left join clients c on vr.playerID = c.dbid group by vr.playerID order by totalPoints desc, c.voteStreaks desc limit ?;");
  1504. searchStatement.setInt(1, maxPosition);
  1505. rs = searchStatement.executeQuery();
  1506.  
  1507. while (rs.next()) {
  1508. int playerID = rs.getInt(1);
  1509. String playerName = rs.getString(2);
  1510. int totalPoints = rs.getInt(3);
  1511. float voteStreaks = rs.getFloat(4);
  1512. if (totalPoints > 0)
  1513. topVoters.add(new ContestWinners(playerID, playerName, totalPoints, voteStreaks));
  1514. }
  1515. } catch (SQLException e) {
  1516. e.printStackTrace();
  1517. } finally {
  1518. databaseConnection.close(searchStatement);
  1519. databaseConnection.close(rs);
  1520. databaseConnection.release();
  1521. }
  1522. return topVoters;
  1523. }
  1524.  
  1525. public static void truncateTable(String tableName) {
  1526. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1590");
  1527. if (databaseConnection == null) {
  1528. GameDatabase.getActionManager().reportUnavailableConnection();
  1529. return;
  1530. }
  1531. PreparedStatement insertStatement = null;
  1532.  
  1533. try {
  1534. insertStatement = databaseConnection.prepareStatement("TRUNCATE " + tableName + ";");
  1535. insertStatement.executeUpdate();
  1536. VoteContest.update();
  1537. } catch (SQLException e) {
  1538. e.printStackTrace();
  1539. } finally {
  1540. databaseConnection.close(insertStatement);
  1541. databaseConnection.release();
  1542. }
  1543. }
  1544.  
  1545. public static String removeDevSupporter(Client c, String playerName) {
  1546. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1553");
  1547. if (databaseConnection == null) {
  1548. GameDatabase.getActionManager().reportUnavailableConnection();
  1549. return "Database error";
  1550. }
  1551. PreparedStatement insertStatement = null;
  1552. try {
  1553. insertStatement = databaseConnection.prepareStatement("delete from supportGroup where playerName = ?;");
  1554. insertStatement.setString(1, playerName);
  1555. int deleted = insertStatement.executeUpdate();
  1556.  
  1557. return deleted > 0 ? "<img=4>" + playerName + " was successfully removed from supporters list." : "<img=4>" + playerName + " couldn't be removed from supporters list.";
  1558. } catch (SQLException e) {
  1559. e.printStackTrace();
  1560. return "<img=4>Unknown error: " + e.getErrorCode();
  1561. }
  1562. }
  1563. public static void registerVoteContestWinner(ContestWinners contestWinner) {
  1564. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1622");
  1565. if (databaseConnection == null) {
  1566. GameDatabase.getActionManager().reportUnavailableConnection();
  1567. return;
  1568. }
  1569. PreparedStatement insertStatement = null;
  1570. int playerID = contestWinner.getPlayerID();
  1571. String playerName = contestWinner.getPlayerName();
  1572. int position = contestWinner.getPosition();
  1573. int points = contestWinner.getTotalPoints();
  1574. float voteStreaks = contestWinner.getVoteStreaks();
  1575.  
  1576. try {
  1577. insertStatement = databaseConnection.prepareStatement("INSERT INTO votes_winners (playerID, playerName, position, points, voteStreaks) VALUES (?, ?, ?, ?, ?);");
  1578. insertStatement.setInt(1, playerID);
  1579. insertStatement.setString(2, playerName);
  1580. insertStatement.setInt(3, position);
  1581. insertStatement.setInt(4, points);
  1582. insertStatement.setFloat(5, voteStreaks);
  1583.  
  1584. insertStatement.executeUpdate();
  1585. VoteContest.update();
  1586.  
  1587. } catch (SQLException e) {
  1588. e.printStackTrace();
  1589. } finally {
  1590. databaseConnection.close(insertStatement);
  1591. databaseConnection.release();
  1592. }
  1593. }
  1594.  
  1595. public static ArrayList<ContestWinners> getLatestWinners(int maxResults) {
  1596. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1642");
  1597. if (databaseConnection == null) {
  1598. GameDatabase.getActionManager().reportUnavailableConnection();
  1599. return null;
  1600. }
  1601. ArrayList<ContestWinners> topVoters = new ArrayList<ContestWinners>();
  1602. PreparedStatement searchStatement = null;
  1603. ResultSet rs = null;
  1604. try {
  1605. searchStatement = databaseConnection.prepareStatement("select playerID, playerName, position, points, voteStreaks, dateTime from votes_winners order by dateTime desc, position asc limit ?;");
  1606. searchStatement.setInt(1, maxResults);
  1607. rs = searchStatement.executeQuery();
  1608.  
  1609. while (rs.next()) {
  1610. int playerID = rs.getInt(1);
  1611. String playerName = rs.getString(2);
  1612. int position = rs.getInt(3);
  1613. int totalPoints = rs.getInt(4);
  1614. float voteStreaks = rs.getFloat(5);
  1615. Timestamp dateTime = rs.getTimestamp(6);
  1616. topVoters.add(new ContestWinners(playerID, playerName, totalPoints, position, voteStreaks, dateTime));
  1617. }
  1618. } catch (SQLException e) {
  1619. e.printStackTrace();
  1620. } finally {
  1621. databaseConnection.close(searchStatement);
  1622. databaseConnection.close(rs);
  1623. databaseConnection.release();
  1624. }
  1625. return topVoters;
  1626. }
  1627.  
  1628. public static void addVotingLotteryEntry(VoteLottery.LotteryEntry lotteryEntry) {
  1629. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1675");
  1630. if (databaseConnection == null) {
  1631. GameDatabase.getActionManager().reportUnavailableConnection();
  1632. return;
  1633. }
  1634. PreparedStatement insertStatement = null;
  1635.  
  1636. try {
  1637. insertStatement = databaseConnection.prepareStatement("INSERT INTO voting_lottery (playerID, playerName) VALUES (?, ?);");
  1638. insertStatement.setInt(1, lotteryEntry.getPlayerID());
  1639. insertStatement.setString(2, lotteryEntry.getPlayerName());
  1640. insertStatement.executeUpdate();
  1641. } catch (SQLException e) {
  1642. e.printStackTrace();
  1643. } finally {
  1644. databaseConnection.close(insertStatement);
  1645. databaseConnection.release();
  1646. }
  1647. }
  1648.  
  1649. public static VoteLottery.LotteryEntry sortVotingLoteryWinner() {
  1650. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1697");
  1651. if (databaseConnection == null) {
  1652. GameDatabase.getActionManager().reportUnavailableConnection();
  1653. return null;
  1654. }
  1655. PreparedStatement searchStatement = null;
  1656. ResultSet rs = null;
  1657. try {
  1658. searchStatement = databaseConnection.prepareStatement("SELECT playerID, playerName FROM voting_lottery ORDER BY RAND() LIMIT 0, 1;");
  1659. rs = searchStatement.executeQuery();
  1660.  
  1661. while (rs.next()) {
  1662. int playerID = rs.getInt(1);
  1663. String playerName = rs.getString(2);
  1664. return new VoteLottery.LotteryEntry(playerID, playerName);
  1665. }
  1666. } catch (SQLException e) {
  1667. e.printStackTrace();
  1668. } finally {
  1669. databaseConnection.close(searchStatement);
  1670. databaseConnection.close(rs);
  1671. databaseConnection.release();
  1672. }
  1673. return null;
  1674. }
  1675.  
  1676. public static void addVotingLotteryWinner(VoteLottery.LotteryEntry lotteryEntry, GameItem gameItem) {
  1677. if (gameItem == null) {
  1678. return;
  1679. }
  1680. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1724");
  1681. if (databaseConnection == null) {
  1682. GameDatabase.getActionManager().reportUnavailableConnection();
  1683. return;
  1684. }
  1685. PreparedStatement insertStatement = null;
  1686.  
  1687. try {
  1688. insertStatement = databaseConnection.prepareStatement("INSERT INTO votes_lottery_winners (playerID, playerName, itemID, itemAmount) VALUES (?, ?, ?, ?);");
  1689. insertStatement.setInt(1, lotteryEntry.getPlayerID());
  1690. insertStatement.setString(2, lotteryEntry.getPlayerName());
  1691. insertStatement.setInt(3, gameItem.getItemID());
  1692. insertStatement.setInt(4, gameItem.getItemAmount());
  1693. insertStatement.executeUpdate();
  1694. } catch (SQLException e) {
  1695. e.printStackTrace();
  1696. } finally {
  1697. databaseConnection.close(insertStatement);
  1698. databaseConnection.release();
  1699. }
  1700. }
  1701.  
  1702. public static ArrayList<SaleType> selectAvailableSales() {
  1703. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1744");
  1704. if (databaseConnection == null) {
  1705. GameDatabase.getActionManager().reportUnavailableConnection();
  1706. return null;
  1707. }
  1708. ArrayList<SaleType> availableSales = new ArrayList<SaleType>();
  1709. PreparedStatement searchStatement = null;
  1710. ResultSet rs = null;
  1711. try {
  1712. searchStatement = databaseConnection.prepareStatement("select s.saleID, s.announcement, s.expireTime from sale s join sale_item si on s.saleID = si.saleID and s.expireTime != 0;");
  1713. rs = searchStatement.executeQuery();
  1714.  
  1715. while (rs.next()) {
  1716. int saleID = rs.getInt(1);
  1717. String announcement = rs.getString(2);
  1718. long expireTime = rs.getLong(3);
  1719. availableSales.add(new SaleType(saleID, announcement, expireTime));
  1720. }
  1721. } catch (SQLException e) {
  1722. e.printStackTrace();
  1723. } finally {
  1724. databaseConnection.close(searchStatement);
  1725. databaseConnection.close(rs);
  1726. databaseConnection.release();
  1727. }
  1728. return availableSales;
  1729. }
  1730.  
  1731. public static void deleteSales(String saleIDs) {
  1732. if (saleIDs == null || saleIDs.isEmpty()) {
  1733. return;
  1734. }
  1735. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1777");
  1736. if (databaseConnection == null) {
  1737. GameDatabase.getActionManager().reportUnavailableConnection();
  1738. return;
  1739. }
  1740. PreparedStatement deleteStatement = null;
  1741.  
  1742. try {
  1743. deleteStatement = databaseConnection.prepareStatement("DELETE `sale`, `sale_item` from `sale` left join `sale_item` on `sale`.`saleID` = `sale_item`.`saleID` where sale.saleID in (" + saleIDs + ");");
  1744. deleteStatement.executeUpdate();
  1745. } catch (SQLException e) {
  1746. e.printStackTrace();
  1747. } finally {
  1748. databaseConnection.close(deleteStatement);
  1749. databaseConnection.release();
  1750. }
  1751. }
  1752.  
  1753. public static void deleteSale(int saleID) {
  1754. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1796");
  1755. if (databaseConnection == null) {
  1756. GameDatabase.getActionManager().reportUnavailableConnection();
  1757. return;
  1758. }
  1759. PreparedStatement deleteStatement = null;
  1760.  
  1761. try {
  1762. deleteStatement = databaseConnection.prepareStatement("DELETE `sale`, `sale_item` from `sale` left join `sale_item` on `sale`.`saleID` = `sale_item`.`saleID` where sale.saleID = ?;");
  1763. deleteStatement.setInt(1, saleID);
  1764. deleteStatement.executeUpdate();
  1765. } catch (SQLException e) {
  1766. e.printStackTrace();
  1767. } finally {
  1768. databaseConnection.close(deleteStatement);
  1769. databaseConnection.release();
  1770. }
  1771. }
  1772.  
  1773. public static ArrayList<ShopSaleItem> selectSaleItems() {
  1774. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1816");
  1775. if (databaseConnection == null) {
  1776. GameDatabase.getActionManager().reportUnavailableConnection();
  1777. return null;
  1778. }
  1779. ArrayList<ShopSaleItem> availableSales = new ArrayList<ShopSaleItem>();
  1780. PreparedStatement searchStatement = null;
  1781. ResultSet rs = null;
  1782. try {
  1783. searchStatement = databaseConnection.prepareStatement("select sale_item.`index`, sale.saleID, itemID, itemAmount, itemPrice, rankType, expireTime from sale_item join sale on sale_item.saleID = sale.saleID and sale_item.itemAmount != 0 && sale_item.itemPrice > 0 and (sale.expireTime = -1 || UNIX_TIMESTAMP(NOW()) < (sale.expireTime / 1000));");
  1784. rs = searchStatement.executeQuery();
  1785.  
  1786. while (rs.next()) {
  1787. int index = rs.getInt(1);
  1788. int saleID = rs.getInt(2);
  1789. int itemID = rs.getInt(3);
  1790. int itemAmount = rs.getInt(4);
  1791. int itemPrice = rs.getInt(5);
  1792. int rankType = rs.getInt(6);
  1793. long expireTime = rs.getLong(7);
  1794. availableSales.add(new ShopSaleItem(index, saleID, itemID, itemAmount, itemPrice, expireTime, rankType));
  1795. }
  1796. } catch (SQLException e) {
  1797. e.printStackTrace();
  1798. } finally {
  1799. databaseConnection.close(searchStatement);
  1800. databaseConnection.close(rs);
  1801. databaseConnection.release();
  1802. }
  1803. return availableSales;
  1804. }
  1805.  
  1806. public static int getAvailableSaleItem(int itemIndex) {
  1807. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1850");
  1808. if (databaseConnection == null) {
  1809. GameDatabase.getActionManager().reportUnavailableConnection();
  1810. return 0;
  1811. }
  1812. PreparedStatement searchStatement = null;
  1813. ResultSet rs = null;
  1814. try {
  1815. searchStatement = databaseConnection.prepareStatement("select itemAmount from sale_item where `index` = ?;");
  1816. searchStatement.setInt(1, itemIndex);
  1817. rs = searchStatement.executeQuery();
  1818.  
  1819. if (rs.next()) {
  1820. int itemAmount = rs.getInt(1);
  1821. return itemAmount;
  1822. }
  1823. } catch (SQLException e) {
  1824. e.printStackTrace();
  1825. } finally {
  1826. databaseConnection.close(searchStatement);
  1827. databaseConnection.close(rs);
  1828. databaseConnection.release();
  1829. }
  1830. return 0;
  1831. }
  1832.  
  1833. public static boolean reduceAvailableItem(int itemIndex, int reduceAmount) {
  1834. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1877");
  1835. if (databaseConnection == null) {
  1836. GameDatabase.getActionManager().reportUnavailableConnection();
  1837. return false;
  1838. }
  1839. PreparedStatement reduceStatement = null;
  1840. ResultSet rs = null;
  1841. try {
  1842. reduceStatement = databaseConnection.prepareStatement("UPDATE sale_item set itemAmount = itemAmount - ? where `index` = ?;");
  1843. reduceStatement.setInt(1, reduceAmount);
  1844. reduceStatement.setInt(2, itemIndex);
  1845. return reduceStatement.executeUpdate() > 0;
  1846. } catch (SQLException e) {
  1847. e.printStackTrace();
  1848. } finally {
  1849. databaseConnection.close(reduceStatement);
  1850. databaseConnection.close(rs);
  1851. databaseConnection.release();
  1852. }
  1853. return false;
  1854. }
  1855.  
  1856. public static void insertOnlineTime(int accountID, int loginHash, long onlineTime) {
  1857. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "1900");
  1858. if (databaseConnection == null) {
  1859. return;
  1860. }
  1861. PreparedStatement updateStatement = null;
  1862. try {
  1863. updateStatement = databaseConnection.prepareStatement("replace into time_online_log (playerID, loginHash, onlineTime) values (?, ?, ?);");
  1864. updateStatement.setInt(1, accountID);
  1865. updateStatement.setInt(2, loginHash);
  1866. updateStatement.setLong(3, onlineTime);
  1867. updateStatement.executeUpdate();
  1868. } catch (Exception e) {
  1869. e.printStackTrace();
  1870. } finally {
  1871. databaseConnection.close(updateStatement);
  1872. databaseConnection.release();
  1873. }
  1874. }
  1875.  
  1876. public static void setMiddleManStatus(String playerName, boolean middleman) {
  1877. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "1920");
  1878. if (databaseConnection == null) {
  1879. return;
  1880. }
  1881. PreparedStatement updateStatement = null;
  1882. try {
  1883. updateStatement = databaseConnection.prepareStatement("update clients set middleman = ? where playerName = ?;");
  1884. updateStatement.setBoolean(1, middleman);
  1885. updateStatement.setString(2, playerName);
  1886. updateStatement.executeUpdate();
  1887. } catch (Exception e) {
  1888. e.printStackTrace();
  1889. } finally {
  1890. databaseConnection.close(updateStatement);
  1891. databaseConnection.release();
  1892. }
  1893.  
  1894. }
  1895.  
  1896. public static boolean hasPreviousPasswords(int accountID, String password) {
  1897. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1940");
  1898. if (databaseConnection == null) {
  1899. GameDatabase.getActionManager().reportUnavailableConnection();
  1900. return false;
  1901. }
  1902. PreparedStatement matchesCount = null;
  1903. ResultSet rs = null;
  1904. try {
  1905. matchesCount = databaseConnection.prepareStatement("SELECT COUNT(*) FROM passchangelogs WHERE dbid = ? AND oldPassword = ?;");
  1906. matchesCount.setInt(1, accountID);
  1907. matchesCount.setString(2, password);
  1908. rs = matchesCount.executeQuery();
  1909. if (rs.next()) {
  1910. int count = rs.getInt(1);
  1911. return count > 0;
  1912. }
  1913. } catch (Exception e) {
  1914. e.printStackTrace();
  1915. } finally {
  1916. databaseConnection.close(matchesCount);
  1917. databaseConnection.release();
  1918. }
  1919. return false;
  1920. }
  1921.  
  1922. public static SaleType selectSale(int saleID) {
  1923. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "1966");
  1924. if (databaseConnection == null) {
  1925. GameDatabase.getActionManager().reportUnavailableConnection();
  1926. return null;
  1927. }
  1928. PreparedStatement searchStatement = null;
  1929. ResultSet rs = null;
  1930. try {
  1931. searchStatement = databaseConnection.prepareStatement("select s.saleID, s.announcement, s.expireTime from sale s join sale_item si on s.saleID = si.saleID and s.expireTime != 0 and s.saleID = ?;");
  1932. searchStatement.setInt(1, saleID);
  1933. rs = searchStatement.executeQuery();
  1934.  
  1935. if (rs.next()) {
  1936. saleID = rs.getInt(1);
  1937. String announcement = rs.getString(2);
  1938. long expireTime = rs.getLong(3);
  1939. return new SaleType(saleID, announcement, expireTime);
  1940. }
  1941. } catch (SQLException e) {
  1942. e.printStackTrace();
  1943. } finally {
  1944. databaseConnection.close(searchStatement);
  1945. databaseConnection.close(rs);
  1946. databaseConnection.release();
  1947. }
  1948. return null;
  1949. }
  1950.  
  1951. public static void insertSaleHistory(int accountID, int itemID, int itemAmount, int totalPaid) {
  1952. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "1995");
  1953. if (databaseConnection == null) {
  1954. return;
  1955. }
  1956. PreparedStatement updateStatement = null;
  1957. try {
  1958. updateStatement = databaseConnection.prepareStatement("INSERT INTO sale_deals (playerID, itemID, itemAmount, totalPrice) VALUES(?, ?, ?, ?);");
  1959. updateStatement.setInt(1, accountID);
  1960. updateStatement.setInt(2, itemID);
  1961. updateStatement.setInt(3, itemAmount);
  1962. updateStatement.setInt(4, totalPaid);
  1963. updateStatement.executeUpdate();
  1964. } catch (Exception e) {
  1965. e.printStackTrace();
  1966. } finally {
  1967. databaseConnection.close(updateStatement);
  1968. databaseConnection.release();
  1969. }
  1970. }
  1971.  
  1972. public static boolean changePassword(int accountID, String newPassword) {
  1973. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2016");
  1974. if (databaseConnection == null) {
  1975. return false;
  1976. }
  1977. PreparedStatement updateStatement = null;
  1978. try {
  1979. String encryptedPassword = BCrypt.hashpw(Config.SALT_PRE + newPassword + Config.SALT_POST, BCrypt.gensalt(Config.SALT_STRENGTH));
  1980. updateStatement = databaseConnection.prepareStatement("UPDATE clients SET encryptedPass = ? where dbid = ?;");
  1981. updateStatement.setString(1, encryptedPassword);
  1982. updateStatement.setInt(2, accountID);
  1983. return updateStatement.executeUpdate() > 0;
  1984. } catch (Exception e) {
  1985. e.printStackTrace();
  1986. } finally {
  1987. databaseConnection.close(updateStatement);
  1988. databaseConnection.release();
  1989. }
  1990. return false;
  1991. }
  1992.  
  1993. public static boolean removeEmail(String playerName) {
  1994. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2038");
  1995. if (databaseConnection == null) {
  1996. return false;
  1997. }
  1998. PreparedStatement updateStatement = null;
  1999. try {
  2000. updateStatement = databaseConnection.prepareStatement("UPDATE clients SET playerEmail = NULL where playerName = ?;");
  2001. updateStatement.setString(1, playerName);
  2002. return updateStatement.executeUpdate() > 0;
  2003. } catch (Exception e) {
  2004. e.printStackTrace();
  2005. } finally {
  2006. databaseConnection.close(updateStatement);
  2007. databaseConnection.release();
  2008. }
  2009. return false;
  2010. }
  2011.  
  2012. public static ArrayList<ReaperCollectionItem> getReaperCollectionItems(Client c) {
  2013. ArrayList<ReaperCollectionItem> collectionItems = new ArrayList<ReaperCollectionItem>();
  2014.  
  2015. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "2055");
  2016. if (databaseConnection == null) {
  2017. GameDatabase.getActionManager().reportUnavailableConnection();
  2018. return null;
  2019. }
  2020. PreparedStatement searchStatement = null;
  2021. ResultSet rs = null;
  2022. try {
  2023. searchStatement = databaseConnection.prepareStatement("select itemIndex, itemID, itemAmount, lostTime from reaper_collection where playerID = ? order by lostTime desc;");
  2024. searchStatement.setInt(1, c.accountID);
  2025. rs = searchStatement.executeQuery();
  2026.  
  2027. while (rs.next()) {
  2028. int itemIndex = rs.getInt(1);
  2029. int itemID = rs.getInt(2);
  2030. int itemAmount = rs.getInt(3);
  2031. Timestamp lostTime = rs.getTimestamp(4);
  2032. collectionItems.add(new ReaperCollectionItem(itemIndex, new GameItem(itemID, itemAmount), lostTime.getTime()));
  2033. }
  2034.  
  2035. } catch (SQLException e) {
  2036. e.printStackTrace();
  2037. } finally {
  2038. databaseConnection.close(searchStatement);
  2039. databaseConnection.close(rs);
  2040. databaseConnection.release();
  2041. }
  2042. return collectionItems;
  2043. }
  2044.  
  2045. public static boolean removeReaperCollectionItem(int itemIndex) {
  2046. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2086");
  2047. if (databaseConnection == null) {
  2048. return false;
  2049. }
  2050. PreparedStatement updateStatement = null;
  2051. try {
  2052. updateStatement = databaseConnection.prepareStatement("DELETE FROM reaper_collection WHERE itemIndex = ?;");
  2053. updateStatement.setInt(1, itemIndex);
  2054. return updateStatement.executeUpdate() > 0;
  2055. } catch (Exception e) {
  2056. e.printStackTrace();
  2057. } finally {
  2058. databaseConnection.close(updateStatement);
  2059. databaseConnection.release();
  2060. }
  2061. return false;
  2062. }
  2063.  
  2064. public static void insertIntoReaperCollection(GameItem gameItem, int accountOwner) {
  2065. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2105");
  2066. if (databaseConnection == null) {
  2067. return;
  2068. }
  2069. if (gameItem == null) {
  2070. return;
  2071. }
  2072. PreparedStatement updateStatement = null;
  2073. try {
  2074. updateStatement = databaseConnection.prepareStatement("INSERT INTO reaper_collection (playerID, itemID, itemAmount) VALUES(?, ?, ?);");
  2075. updateStatement.setInt(1, accountOwner);
  2076. updateStatement.setInt(2, gameItem.getItemID());
  2077. updateStatement.setInt(3, gameItem.getItemAmount());
  2078. updateStatement.executeUpdate();
  2079. } catch (Exception e) {
  2080. e.printStackTrace();
  2081. } finally {
  2082. databaseConnection.close(updateStatement);
  2083. databaseConnection.release();
  2084. }
  2085. }
  2086.  
  2087. public static boolean hasRedemeedInvoice(int invoiceID) {
  2088. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "2166");
  2089. if (databaseConnection == null) {
  2090. GameDatabase.getActionManager().reportUnavailableConnection();
  2091. return true;
  2092. }
  2093. PreparedStatement searchStatement = null;
  2094. ResultSet rs = null;
  2095. try {
  2096. searchStatement = databaseConnection.prepareStatement("SELECT * FROM donationlogs WHERE invoice = ? LIMIT 1;");
  2097. searchStatement.setInt(1, invoiceID);
  2098. rs = searchStatement.executeQuery();
  2099.  
  2100. return rs.next();
  2101. } catch (SQLException e) {
  2102. e.printStackTrace();
  2103. } finally {
  2104. databaseConnection.close(searchStatement);
  2105. databaseConnection.close(rs);
  2106. databaseConnection.release();
  2107. }
  2108. return false;
  2109. }
  2110.  
  2111. public static boolean clearCollectBox(int playerID) {
  2112. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2128");
  2113. if (databaseConnection == null) {
  2114. return false;
  2115. }
  2116. PreparedStatement updateStatement = null;
  2117. try {
  2118. updateStatement = databaseConnection.prepareStatement("delete from collect where player =?;");
  2119. updateStatement.setInt(1, playerID);
  2120. return updateStatement.executeUpdate() > 0;
  2121. } catch (Exception e) {
  2122. e.printStackTrace();
  2123. } finally {
  2124. databaseConnection.close(updateStatement);
  2125. databaseConnection.release();
  2126. }
  2127. return false;
  2128. }
  2129.  
  2130. public static int hasAppAccess(String user, String password, String device) {
  2131. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(PlayerDatabase.class.getSimpleName() + ":" + "2209");
  2132. if (databaseConnection == null) {
  2133. GameDatabase.getActionManager().reportUnavailableConnection();
  2134. return 4;
  2135. }
  2136. PreparedStatement searchStatement = null;
  2137. ResultSet rs = null;
  2138. try {
  2139. searchStatement = databaseConnection.prepareStatement("SELECT password, device FROM app_access WHERE user = ? LIMIT 1;");
  2140. searchStatement.setString(1, user);
  2141. rs = searchStatement.executeQuery();
  2142.  
  2143. if (rs.next()) {
  2144. String accountPassword = rs.getString(1);
  2145. String accountDevice = rs.getString(2);
  2146. if (!accountPassword.equals(password)) {
  2147. return 2;
  2148. }
  2149. if (!accountDevice.equals(device)) {
  2150. return 3;
  2151. }
  2152. return 1;
  2153. } else {
  2154. return 2;
  2155. }
  2156. } catch (SQLException e) {
  2157. e.printStackTrace();
  2158. } finally {
  2159. databaseConnection.close(searchStatement);
  2160. databaseConnection.close(rs);
  2161. databaseConnection.release();
  2162. }
  2163. return 4;
  2164. }
  2165.  
  2166. public static void insertPremiumExtract(String playerName, int value, String source) {
  2167. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2038");
  2168. if (databaseConnection == null) {
  2169. return;
  2170. }
  2171. PreparedStatement selectStatement = null;
  2172. try {
  2173. selectStatement = databaseConnection.prepareStatement("Select dbid, donorpoints, connectedFrom, regSerial, playerMacAdress from clients where playerName = ?;");
  2174. selectStatement.setString(1, playerName);
  2175. ResultSet rs = selectStatement.executeQuery();
  2176. if (rs.next()) {
  2177. int accountID = rs.getInt(1);
  2178. int balance = rs.getInt(2);
  2179. String host = rs.getString(3);
  2180. String serial = rs.getString(4);
  2181. String macAddress = rs.getString(5);
  2182. PremiumExtractDAO premiumExtract = new PremiumExtractDAO(accountID, balance, host, serial, macAddress, ExtractType.INCOME, source, value, 0, 0);
  2183. PassiveDatabaseWorker.addRequest(premiumExtract);
  2184. }
  2185.  
  2186. } catch (Exception e) {
  2187. e.printStackTrace();
  2188. } finally {
  2189. databaseConnection.close(selectStatement);
  2190. databaseConnection.release();
  2191. }
  2192.  
  2193. }
  2194.  
  2195. public static int rewardPremiumPoints(int points, String playerName) {
  2196. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2038");
  2197. if (databaseConnection == null) {
  2198. return -1;
  2199. }
  2200. PreparedStatement updateStatement = null;
  2201. try {
  2202. updateStatement = databaseConnection.prepareStatement("UPDATE clients SET donorPoints = donorPoints + ? WHERE playerName = ?;");
  2203. updateStatement.setInt(1, points);
  2204. updateStatement.setString(2, playerName);
  2205. return updateStatement.executeUpdate();
  2206. } catch (Exception e) {
  2207. e.printStackTrace();
  2208. } finally {
  2209. databaseConnection.close(updateStatement);
  2210. databaseConnection.release();
  2211. }
  2212. return 0;
  2213. }
  2214.  
  2215. public static void updatePvPScores(Client c, int pvpScores) {
  2216. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2296");
  2217. if (databaseConnection == null) {
  2218. return;
  2219. }
  2220. PreparedStatement updateStatement = null;
  2221. try {
  2222. updateStatement = databaseConnection.prepareStatement("INSERT INTO player_killing_score (player_id, pk_score) VALUES(?, ?) ON DUPLICATE KEY UPDATE pk_score = VALUES(pk_score);");
  2223. updateStatement.setInt(1, c.accountID);
  2224. updateStatement.setInt(2, pvpScores);
  2225. updateStatement.executeUpdate();
  2226. } catch (Exception e) {
  2227. e.printStackTrace();
  2228. } finally {
  2229. databaseConnection.close(updateStatement);
  2230. databaseConnection.release();
  2231. }
  2232. }
  2233.  
  2234. public static boolean callRoutine(String routineName) {
  2235. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2317");
  2236. if (databaseConnection == null) {
  2237. return false;
  2238. }
  2239. try {
  2240. databaseConnection.executeQuery("CALL `" + routineName + "`();");
  2241. return true;
  2242. } catch (Exception e) {
  2243. e.printStackTrace();
  2244. } finally {
  2245. databaseConnection.release();
  2246. }
  2247. return false;
  2248. }
  2249.  
  2250. public static int getPvPRank(Client c) {
  2251. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2333");
  2252. if (databaseConnection == null) {
  2253. return 0;
  2254. }
  2255. PreparedStatement updateStatement = null;
  2256. try {
  2257. updateStatement = databaseConnection.prepareStatement("SELECT rank FROM player_killing_rank WHERE player_id = ?;");
  2258. updateStatement.setInt(1, c.accountID);
  2259. ResultSet rs = updateStatement.executeQuery();
  2260. return rs != null && rs.next() ? rs.getInt(1) : 0;
  2261. } catch (Exception e) {
  2262. e.printStackTrace();
  2263. } finally {
  2264. databaseConnection.close(updateStatement);
  2265. databaseConnection.release();
  2266. }
  2267. return 0;
  2268. }
  2269.  
  2270. public static int getPvPScores(Client c, DatabaseConnection databaseConnection) {
  2271. if (databaseConnection == null) {
  2272. databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2318");
  2273. }
  2274. if (databaseConnection == null) {
  2275. return 0;
  2276. }
  2277. PreparedStatement updateStatement = null;
  2278. try {
  2279. updateStatement = databaseConnection.prepareStatement("SELECT pk_score FROM player_killing_score WHERE player_id = ?;");
  2280. updateStatement.setInt(1, c.accountID);
  2281. ResultSet rs = updateStatement.executeQuery();
  2282. return rs != null && rs.next() ? rs.getInt(1) : 0;
  2283. } catch (Exception e) {
  2284. e.printStackTrace();
  2285. } finally {
  2286. databaseConnection.close(updateStatement);
  2287. databaseConnection.release();
  2288. }
  2289. return 0;
  2290. }
  2291.  
  2292. public static void registerAccountCreation(int playerID, String playerName, long creationTime, String connectedFrom, String playerMacAdress, String regSerial, String systemName) {
  2293. RequestModel requestModel = new RequestModel(null, QueryType.UPDATE, GameDatabase.getActionManager()) {
  2294.  
  2295. @Override
  2296. public PreparedStatement prepareStatement(DatabaseConnection databaseConnection) {
  2297. if (databaseConnection != null) {
  2298. try {
  2299. PreparedStatement statement = databaseConnection.prepareStatement("INSERT INTO account_registration (playerID, playerName, registerDateTime, hostAddress, macAddress, regSerial, systemName) VALUES(?, ?, ?, ?, ?, ?, ?);");
  2300. statement.setInt(1, playerID);
  2301. statement.setString(2, playerName);
  2302. statement.setTimestamp(3, new Timestamp(creationTime));
  2303. statement.setString(4, connectedFrom);
  2304. statement.setString(5, playerMacAdress);
  2305. statement.setString(6, regSerial);
  2306. statement.setString(7, systemName);
  2307. return statement;
  2308. } catch (SQLException e) {
  2309. e.printStackTrace();
  2310. }
  2311. }
  2312. return null;
  2313. }
  2314.  
  2315. @Override
  2316. public void future() {
  2317.  
  2318. }
  2319. };
  2320. Server.asyncDatabaseWorker.submitModel(requestModel);
  2321. }
  2322.  
  2323. public static void addMoney(int playerID, int amount) {
  2324. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2444");
  2325. if (databaseConnection == null) {
  2326. return;
  2327. }
  2328. PreparedStatement updateStatement = null;
  2329. try {
  2330. updateStatement = databaseConnection.prepareStatement("INSERT INTO player_definitions (player_id, cash_reward) VALUES(?, ?) ON DUPLICATE KEY UPDATE cash_reward = cash_reward + VALUES(cash_reward);");
  2331. updateStatement.setInt(1, playerID);
  2332. updateStatement.setInt(2, amount);
  2333. updateStatement.executeUpdate();
  2334. } catch (Exception e) {
  2335. e.printStackTrace();
  2336. } finally {
  2337. databaseConnection.close(updateStatement);
  2338. databaseConnection.release();
  2339. }
  2340. }
  2341.  
  2342. public static void addPlayerKillingPoints(int playerID, int amount) {
  2343. Client player = PlayerHandler.getClient(playerID);
  2344. if (player != null) {
  2345. player.pkingPoints += amount;
  2346. return;
  2347. }
  2348.  
  2349. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2469");
  2350. if (databaseConnection == null) {
  2351. return;
  2352. }
  2353. PreparedStatement updateStatement = null;
  2354. try {
  2355. updateStatement = databaseConnection.prepareStatement("UPDATE clients c SET pkingPoints = c.pkingPoints + ? WHERE dbid = ?;");
  2356. updateStatement.setInt(1, amount);
  2357. updateStatement.setInt(2, playerID);
  2358. updateStatement.executeUpdate();
  2359. } catch (Exception e) {
  2360. e.printStackTrace();
  2361. } finally {
  2362. databaseConnection.close(updateStatement);
  2363. databaseConnection.release();
  2364. }
  2365. }
  2366.  
  2367. public static void addTournamentPoints(int playerID, int amount) {
  2368. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2488");
  2369. if (databaseConnection == null) {
  2370. return;
  2371. }
  2372. PreparedStatement updateStatement = null;
  2373. try {
  2374. updateStatement = databaseConnection.prepareStatement("INSERT INTO player_definitions (player_id, tournament_points) VALUES(?, ?) ON DUPLICATE KEY UPDATE tournament_points = tournament_points + VALUES(tournament_points);");
  2375. updateStatement.setInt(1, playerID);
  2376. updateStatement.setInt(2, amount);
  2377. updateStatement.executeUpdate();
  2378. } catch (Exception e) {
  2379. e.printStackTrace();
  2380. } finally {
  2381. databaseConnection.close(updateStatement);
  2382. databaseConnection.release();
  2383. }
  2384. }
  2385.  
  2386. public static void addPendingAction(int playerID, String actionType, long dateTime) {
  2387. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2512");
  2388. if (databaseConnection == null) {
  2389. return;
  2390. }
  2391. PreparedStatement updateStatement = null;
  2392. try {
  2393. updateStatement = databaseConnection.prepareStatement("INSERT INTO player_pending_action(player_id, type, date_time) VALUES(?, ?, ?);");
  2394. updateStatement.setInt(1, playerID);
  2395. updateStatement.setString(2, actionType);
  2396. updateStatement.setTimestamp(3, new Timestamp(dateTime));
  2397. updateStatement.executeUpdate();
  2398. } catch (Exception e) {
  2399. e.printStackTrace();
  2400. } finally {
  2401. databaseConnection.close(updateStatement);
  2402. databaseConnection.release();
  2403. }
  2404. }
  2405.  
  2406. public static void getPendingActions(Client c, Consumer<List<Tuple<Integer, String>>> dataConsumer) {
  2407. RequestModel requestModel = new RequestModel(c, QueryType.SELECT);
  2408.  
  2409. requestModel.setStatementSupplier(databaseConnection -> {
  2410. PreparedStatement statement = databaseConnection.prepareStatement("SELECT action_id, type FROM player_pending_action WHERE player_id = ? AND date_time <= ?;");
  2411. try {
  2412. statement.setInt(1, c.accountID);
  2413. statement.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
  2414. } catch (SQLException e) {
  2415. e.printStackTrace();
  2416. }
  2417. return statement;
  2418. });
  2419.  
  2420. requestModel.setFuture(rs -> {
  2421. List<Tuple<Integer, String>> pendingActions = new ArrayList<Tuple<Integer, String>>();
  2422. try {
  2423. while (rs.next()) {
  2424. int actionID = rs.getInt(1);
  2425. String actionType = rs.getString(2);
  2426. pendingActions.add(Tuple.of(actionID, actionType));
  2427. }
  2428. } catch (SQLException e) {
  2429. e.printStackTrace();
  2430. }
  2431. if (!pendingActions.isEmpty())
  2432. dataConsumer.accept(pendingActions);
  2433. });
  2434.  
  2435. Server.asyncDatabaseWorker.submitModel(requestModel);
  2436. }
  2437.  
  2438. public static void removePendingActions(List<Integer> actionsID) {
  2439. RequestModel requestModel = new RequestModel(QueryType.UPDATE);
  2440. requestModel.setStatementSupplier(databaseConnection -> {
  2441. String actionTypes = Misc.buildString(actionsID, '\0', ", ");
  2442. return databaseConnection.prepareStatement("DELETE FROM player_pending_action WHERE action_id IN(" + actionTypes + ");");
  2443. });
  2444. Server.asyncDatabaseWorker.submitModel(requestModel);
  2445. }
  2446.  
  2447. public static int getAccountsCreationCount(String playerName, String regSerial, String hostAddress) {
  2448. DatabaseConnection databaseConnection = GameDatabase.getActionManager().getConnection(1000, PlayerDatabase.class.getSimpleName() + ":" + "2575");
  2449. PreparedStatement updateStatement = null;
  2450. try {
  2451. updateStatement = databaseConnection.prepareStatement("SELECT count(*) FROM account_registration WHERE (regSerial = ? || hostAddress = ?) AND playerName != ? AND TIMESTAMPDIFF(HOUR, registerDateTime, NOW()) <= 24;");
  2452. updateStatement.setString(1, regSerial);
  2453. updateStatement.setString(2, hostAddress);
  2454. updateStatement.setString(3, playerName);
  2455. ResultSet rs = updateStatement.executeQuery();
  2456. return rs != null && rs.next() ? rs.getInt(1) : 0;
  2457. } catch (Exception e) {
  2458. e.printStackTrace();
  2459. } finally {
  2460. databaseConnection.close(updateStatement);
  2461. databaseConnection.release();
  2462. }
  2463. return 0;
  2464. }
  2465.  
  2466. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!