package me.theandev.donutorders; import java.sql.Connection; import java.util.function.Function; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.function.Consumer; import de.rapha149.signgui.SignGUIAction; import java.util.List; import java.util.function.BiPredicate; import java.util.stream.Collectors; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Material; import org.bukkit.OfflinePlayer; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; public class OrderRepository { private final DatabaseManager databaseManager; public OrderRepository(DatabaseManager databaseManager) { this.databaseManager = databaseManager; } public void getPlayersOrders(String playerName, Consumer> callback) { List orders = new ArrayList<>(); String sql = "SELECT o.Id, o.Material, o.Player, o.Price, o.Amount, o.DeliveredAmount, o.CollectedAmount, o.Date, o.Properties, o.IsActive, o.CompletedDate FROM orders o WHERE o.Player LIKE ?"; try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmt = connection.prepareStatement(sql)) { pstmt.setString(1, "%" + playerName + "%"); try (ResultSet rs = pstmt.executeQuery()) { orders = this.extractOrdersFromResultSet(rs, true); } } catch (SQLException e) { e.printStackTrace(); } callback.accept(orders); } public void getOrderById(int orderId, Consumer callback) { Order order = null; String sql = "SELECT o.Id, o.Material, o.Player, o.Price, o.Amount, o.DeliveredAmount, o.CollectedAmount, o.Date, o.Properties, o.IsActive, o.CompletedDate FROM orders o WHERE o.Id = ?"; try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmt = connection.prepareStatement(sql)) { pstmt.setInt(1, orderId); try (ResultSet rs = pstmt.executeQuery()) { if (rs.next()) order = this.extractOrderFromResultSet(rs); } } catch (SQLException e) { e.printStackTrace(); } callback.accept(order); } private static final java.util.Map ENCHANT_ALIASES = new java.util.HashMap() {{ put("prot", "protection"); put("protect", "protection"); put("fprot", "fire_protection"); put("fp", "fire_protection"); put("fireproto","fire_protection"); put("fire_prot", "fire_protection"); put("bprot", "blast_protection"); put("bp", "blast_protection"); put("blast_prot","blast_protection"); put("pprot", "projectile_protection"); put("pp", "projectile_protection"); put("proj_prot","projectile_protection"); put("sharp", "sharpness"); put("sharpness", "sharpness"); put("smite", "smite"); put("bane", "bane_of_arthropods"); put("boa", "bane_of_arthropods"); put("arthropods","bane_of_arthropods"); put("eff", "efficiency"); put("effi", "efficiency"); put("silk", "silk_touch"); put("silktouch", "silk_touch"); put("fort", "fortune"); put("fortune", "fortune"); put("unb", "unbreaking"); put("unbreak", "unbreaking"); put("mend", "mending"); put("power", "power"); put("punch", "punch"); put("flame", "flame"); put("inf", "infinity"); put("infin", "infinity"); put("feather", "feather_falling"); put("ff", "feather_falling"); put("respire", "respiration"); put("resp", "respiration"); put("aqua", "aqua_affinity"); put("aa", "aqua_affinity"); put("thorns", "thorns"); put("depth", "depth_strider"); put("ds", "depth_strider"); put("frost", "frost_walker"); put("fw", "frost_walker"); put("swift", "swift_sneak"); put("sneak", "swift_sneak"); put("soul", "soul_speed"); put("ss", "soul_speed"); put("kb", "knockback"); put("knock", "knockback"); put("fire_aspect","fire_aspect"); put("fire", "fire_aspect"); put("looting", "looting"); put("loot", "looting"); put("sweeping", "sweeping_edge"); put("sweep", "sweeping_edge"); put("loyalty", "loyalty"); put("loyal", "loyalty"); put("impaling", "impaling"); put("impale", "impaling"); put("riptide", "riptide"); put("rip", "riptide"); put("channel", "channeling"); put("channeling", "channeling"); put("multi", "multishot"); put("multishot", "multishot"); put("quick", "quick_charge"); put("qc", "quick_charge"); put("pierce", "piercing"); put("piercing", "piercing"); put("luck", "luck_of_the_sea"); put("lots", "luck_of_the_sea"); put("lure", "lure"); put("binding", "binding_curse"); put("curse_bind", "binding_curse"); put("vanishing","vanishing_curse"); put("curse_van", "vanishing_curse"); put("dig_speed", "efficiency"); put("digging", "efficiency"); put("damage_all", "sharpness"); put("damage", "sharpness"); put("damage_undead", "smite"); put("undead", "smite"); put("damage_arthropods","bane_of_arthropods"); put("bane_of_arthropods","bane_of_arthropods"); put("durability", "unbreaking"); put("unbr", "unbreaking"); put("arrow_fire", "flame"); put("arrow_damage", "power"); put("arrow_knockback","punch"); put("arrow_infinite", "infinity"); put("loot_bonus_mobs","looting"); put("loot_bonus_blocks","fortune"); put("water_worker", "aqua_affinity"); put("oxygen", "respiration"); put("protection_fall","feather_falling"); put("feather_fall", "feather_falling"); put("protection_fire","fire_protection"); put("protection_explosions","blast_protection"); put("protection_projectile","projectile_protection"); put("protection_environmental","protection"); put("luck_of_the_sea","luck_of_the_sea"); put("fishing_luck", "luck_of_the_sea"); put("fishing_speed", "lure"); put("bane_of_arthropods", "bane_of_arthropods"); put("feather_falling", "feather_falling"); put("fire_protection", "fire_protection"); put("blast_protection", "blast_protection"); put("projectile_protection","projectile_protection"); put("swift_sneak", "swift_sneak"); put("soul_speed", "soul_speed"); put("depth_strider", "depth_strider"); put("frost_walker", "frost_walker"); put("silk_touch", "silk_touch"); put("fire_aspect", "fire_aspect"); put("fire_asp", "fire_aspect"); put("sweeping_edge", "sweeping_edge"); put("quick_charge", "quick_charge"); put("luck_of_the_sea", "luck_of_the_sea"); put("binding_curse", "binding_curse"); put("vanishing_curse", "vanishing_curse"); put("density", "density"); put("dense", "density"); put("breach", "breach"); put("breaching", "breach"); put("wind_burst","wind_burst"); put("wind", "wind_burst"); put("burst", "wind_burst"); }}; private static String resolveEnchantKey(String input) { String key = input.toLowerCase().replace(" ", "_"); if (org.bukkit.enchantments.Enchantment.getByKey( org.bukkit.NamespacedKey.minecraft(key)) != null) return key; String alias = ENCHANT_ALIASES.get(key); if (alias != null && org.bukkit.enchantments.Enchantment.getByKey( org.bukkit.NamespacedKey.minecraft(alias)) != null) return alias; return null; } private static int romanToInt(String s) { if (s == null) return -1; switch (s.toUpperCase()) { case "I": return 1; case "II": return 2; case "III": return 3; case "IV": return 4; case "V": return 5; case "VI": return 6; case "VII": return 7; case "VIII": return 8; case "IX": return 9; case "X": return 10; default: return -1; } } private static SearchQuery parseSearch(String raw) { if (raw == null || raw.isEmpty()) return new SearchQuery(raw, null, null, -1); String[] tokens = raw.trim().split("\s+"); int level = -1; int lastIdx = tokens.length - 1; try { level = Integer.parseInt(tokens[lastIdx]); } catch (NumberFormatException e) { int r = romanToInt(tokens[lastIdx]); if (r > 0) level = r; } int enchantEnd = (level > 0) ? lastIdx : tokens.length; int enchantStart = -1, enchantFinish = -1; String resolvedEnchantKey = null; outer: for (int len = enchantEnd; len >= 1; len--) { for (int i = 0; i + len <= enchantEnd; i++) { String candidate = String.join("_", java.util.Arrays.copyOfRange(tokens, i, i + len)); String resolved = resolveEnchantKey(candidate); if (resolved != null) { enchantStart = i; enchantFinish = i + len; resolvedEnchantKey = resolved.toUpperCase(); break outer; } } } String materialPart = null; String enchantPart = null; if (enchantStart >= 0) { if (enchantStart > 0) materialPart = String.join(" ", java.util.Arrays.copyOfRange(tokens, 0, enchantStart)).toLowerCase(); enchantPart = resolvedEnchantKey; } else { materialPart = String.join(" ", java.util.Arrays.copyOfRange(tokens, 0, enchantEnd)).toLowerCase(); } return new SearchQuery(materialPart, enchantPart, null, level); } private static class SearchQuery { final String material; final String enchant; final String player; final int level; SearchQuery(String material, String enchant, String player, int level) { this.material = material; this.enchant = enchant; this.player = player; this.level = level; } } public void getOrders(OrdersSortOption ordersSortOption, FilterOption filterOption, String search, Consumer> callback) { List orders = new ArrayList<>(); String sortQuery; switch (ordersSortOption) { case MOST_DELIVERED: sortQuery = "DeliveredAmount DESC"; break; case MOST_PAID: sortQuery = "Price DESC"; break; case MOST_MONEY_PER_ITEM: sortQuery = "Price / Amount DESC"; break; default: sortQuery = "Date DESC, Id DESC"; } SearchQuery sq = parseSearch(search); boolean hasEnchant = sq.enchant != null; boolean hasMaterial = sq.material != null && !sq.material.isEmpty(); boolean hasLevel = sq.level > 0; StringBuilder sql = new StringBuilder(); sql.append("SELECT o.Id, o.Material, o.Player, o.Price, o.Amount, o.DeliveredAmount, o.CollectedAmount, o.Date, o.Properties, o.IsActive, o.CompletedDate FROM orders o "); if (filterOption != FilterOption.ALL) { sql.append("INNER JOIN (SELECT DISTINCT MaterialName, FilterOption FROM materials) m ON o.Material = m.MaterialName "); } sql.append("WHERE 1=1 "); if (filterOption != FilterOption.ALL) sql.append("AND m.FilterOption = ? "); sql.append("AND o.IsActive = 1 "); List params = new ArrayList<>(); if (filterOption != FilterOption.ALL) params.add(filterOption.name()); boolean isCategory = search != null && !search.isEmpty() && CategoryManager.isCategory(search.trim()); if (search != null && !search.isEmpty() && !isCategory) { if (hasEnchant) { if (hasMaterial) { sql.append("AND (LOWER(REPLACE(o.Material, '_', ' ')) LIKE LOWER(?) OR LOWER(o.Material) LIKE LOWER(?)) "); params.add("%" + sq.material + "%"); params.add("%" + sq.material.replace(" ", "_") + "%"); } if (hasLevel) { sql.append("AND (LOWER(o.Properties) LIKE LOWER(?) AND LOWER(o.Properties) LIKE LOWER(?)) "); params.add("%" + sq.enchant + "%" ); params.add("%" + sq.enchant + "-" + sq.level + "%"); } else { sql.append("AND LOWER(o.Properties) LIKE LOWER(?) "); params.add("%" + sq.enchant + "%"); } } else if (hasMaterial) { String raw = sq.material; sql.append("AND (LOWER(o.Player) LIKE LOWER(?) OR LOWER(REPLACE(o.Material, '_', ' ')) LIKE LOWER(?) OR LOWER(o.Material) LIKE LOWER(?)) "); params.add("%" + raw + "%"); params.add("%" + raw + "%"); params.add("%" + raw.replace(" ", "_") + "%"); } else { String sp = "%" + search + "%"; sql.append("AND (LOWER(o.Player) LIKE LOWER(?) OR LOWER(REPLACE(o.Material, '_', ' ')) LIKE LOWER(?)) "); params.add(sp); params.add(sp); } } sql.append("ORDER BY ").append(sortQuery); try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmt = connection.prepareStatement(sql.toString())) { for (int i = 0; i < params.size(); i++) pstmt.setString(i + 1, params.get(i)); try (ResultSet rs = pstmt.executeQuery()) { orders = this.extractOrdersFromResultSet(rs, false); } } catch (SQLException e) { e.printStackTrace(); } if (isCategory) { java.util.Set catMaterials = CategoryManager.getCategory(search.trim()); if (catMaterials != null) { orders = orders.stream() .filter(o -> catMaterials.contains(o.getMaterialName().toUpperCase())) .collect(java.util.stream.Collectors.toList()); } } callback.accept(orders); } public void addOrder(String material, String properties, Player player, double price, int amount, String date, Runnable onComplete) { DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { String sql = "INSERT INTO orders (Material, Properties, Player, Price, Amount, DeliveredAmount, CollectedAmount, Date) VALUES (?, ?, ?, ?, ?, 0, 0, ?)"; try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmt = connection.prepareStatement(sql)) { pstmt.setString(1, material); pstmt.setString(2, properties); pstmt.setString(3, player.getName()); pstmt.setDouble(4, price); pstmt.setInt(5, amount); pstmt.setString(6, date); pstmt.executeUpdate(); Bukkit.getScheduler().runTask(DonutOrders.plugin, onComplete); } catch (SQLException e) { e.printStackTrace(); } }); } public void disableOrDeleteOrder(OfflinePlayer player, Order order, Runnable onComplete) { DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmtCheck = connection.prepareStatement( "SELECT DeliveredAmount, CollectedAmount FROM orders WHERE Id = ? AND IsActive = 1")) { pstmtCheck.setInt(1, order.getId()); try (ResultSet rs = pstmtCheck.executeQuery()) { if (rs.next()) { int delivered = rs.getInt("DeliveredAmount"); int collected = rs.getInt("CollectedAmount"); String sqlAction = (delivered - collected == 0) ? "DELETE FROM orders WHERE Id = ?" : "UPDATE orders SET IsActive = 0 WHERE Id = ?"; try (PreparedStatement pstmt = connection.prepareStatement(sqlAction)) { pstmt.setInt(1, order.getId()); pstmt.executeUpdate(); } int leftAmount = order.getAmount() - delivered; if (leftAmount > 0) { Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> HooksManager.getCurrency().giveBalance(player, (double) leftAmount * order.getPrice())); } } if (onComplete != null) Bukkit.getScheduler().runTask(DonutOrders.plugin, onComplete); } } catch (SQLException e) { Bukkit.getScheduler().runTask(DonutOrders.plugin, (Runnable) e::printStackTrace); } }); } public void disableOrDeleteOrdersBatch(OfflinePlayer player, List orders, Runnable onComplete) { if (orders.isEmpty()) return; DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { String ph = orders.stream().map(o -> "?").collect(Collectors.joining(",")); try (Connection connection = this.databaseManager.getConnection(); PreparedStatement pstmtCheck = connection.prepareStatement( "SELECT Id, DeliveredAmount, CollectedAmount FROM orders WHERE Id IN (" + ph + ")")) { int idx = 1; for (Order o : orders) pstmtCheck.setInt(idx++, o.getId()); List toDelete = new ArrayList<>(), toDisable = new ArrayList<>(); HashMap refunds = new HashMap<>(); try (ResultSet rs = pstmtCheck.executeQuery()) { while (rs.next()) { int id = rs.getInt("Id"), del = rs.getInt("DeliveredAmount"), col = rs.getInt("CollectedAmount"); if (del - col == 0) toDelete.add(id); else toDisable.add(id); for (Order ox : orders) { if (ox.getId() == id) { int left = ox.getAmount() - del; if (left > 0) refunds.put(id, (double) left * ox.getPrice()); } } } } if (!toDelete.isEmpty()) { try (PreparedStatement p = connection.prepareStatement("DELETE FROM orders WHERE Id IN (" + toDelete.stream().map(i -> "?").collect(Collectors.joining(",")) + ")")) { for (int i = 0; i < toDelete.size(); i++) p.setInt(i + 1, toDelete.get(i)); p.executeUpdate(); } } if (!toDisable.isEmpty()) { try (PreparedStatement p = connection.prepareStatement("UPDATE orders SET IsActive = 0 WHERE Id IN (" + toDisable.stream().map(i -> "?").collect(Collectors.joining(",")) + ")")) { for (int i = 0; i < toDisable.size(); i++) p.setInt(i + 1, toDisable.get(i)); p.executeUpdate(); } } Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { for (Order o : orders) { if (refunds.containsKey(o.getId())) HooksManager.getCurrency().giveBalance(player, refunds.get(o.getId())); } if (onComplete != null) onComplete.run(); }); } catch (SQLException e) { Bukkit.getScheduler().runTask(DonutOrders.plugin, (Runnable) e::printStackTrace); } }); } public void deliverItems(Order order, Player deliveringPlayer, ItemStack[] rawDeliveringItems, Runnable onSuccess) { final ItemStack[] deliveringItems = java.util.Arrays.stream(rawDeliveringItems) .map(i -> i != null ? i.clone() : null) .toArray(ItemStack[]::new); DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { int[] totalDeliverable = {0}; try (Connection connection = this.databaseManager.getConnection(); PreparedStatement getOrderStmt = connection.prepareStatement("SELECT Amount, DeliveredAmount FROM orders WHERE Id = ? AND IsActive = 1"); PreparedStatement updateOrderStmt = connection.prepareStatement("UPDATE orders SET DeliveredAmount = DeliveredAmount + ?, IsActive = CASE WHEN DeliveredAmount + ? >= Amount THEN 0 ELSE IsActive END WHERE Id = ?")) { getOrderStmt.setInt(1, order.getId()); try (ResultSet rs = getOrderStmt.executeQuery()) { if (!rs.next()) { Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { for (ItemStack item : deliveringItems) if (item != null && item.getType() != Material.AIR) deliveringPlayer.getInventory().addItem(item); }); return; } int remaining = rs.getInt("Amount") - rs.getInt("DeliveredAmount"); for (ItemStack item : deliveringItems) { if (item == null || item.getType() == Material.AIR) continue; if (order.isSameItem(item) && Order.isShulkerBox(item.getType()) && totalDeliverable[0] < remaining) { int add = item.getAmount(); if (totalDeliverable[0] + add > remaining) { ItemStack extra = item.clone(); extra.setAmount(totalDeliverable[0] + add - remaining); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(extra); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); add = remaining - totalDeliverable[0]; } org.bukkit.inventory.meta.BlockStateMeta bsm = (org.bukkit.inventory.meta.BlockStateMeta) item.getItemMeta(); if (bsm != null && bsm.getBlockState() instanceof org.bukkit.block.ShulkerBox) { org.bukkit.block.ShulkerBox shulker = (org.bukkit.block.ShulkerBox) bsm.getBlockState(); for (ItemStack inside : shulker.getInventory().getContents()) { if (inside == null || inside.getType() == Material.AIR) continue; final ItemStack insideCopy = inside.clone(); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(insideCopy); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); } } totalDeliverable[0] += add; } else if (Order.isShulkerBox(item.getType()) && !order.isSameItem(item)) { org.bukkit.inventory.meta.BlockStateMeta bsm = (org.bukkit.inventory.meta.BlockStateMeta) item.getItemMeta(); boolean extractedAny = false; if (bsm != null && bsm.getBlockState() instanceof org.bukkit.block.ShulkerBox) { org.bukkit.block.ShulkerBox shulker = (org.bukkit.block.ShulkerBox) bsm.getBlockState(); org.bukkit.inventory.ItemStack[] insideContents = shulker.getInventory().getContents(); for (int si = 0; si < insideContents.length; si++) { ItemStack inside = insideContents[si]; if (inside == null || inside.getType() == Material.AIR) continue; if (order.isSameItem(inside) && totalDeliverable[0] < remaining) { int add = inside.getAmount(); if (totalDeliverable[0] + add > remaining) { insideContents[si] = inside.clone(); insideContents[si].setAmount(totalDeliverable[0] + add - remaining); add = remaining - totalDeliverable[0]; } else { insideContents[si] = null; } totalDeliverable[0] += add; extractedAny = true; } } shulker.getInventory().setContents(insideContents); bsm.setBlockState(shulker); item.setItemMeta(bsm); } final ItemStack shulkerToReturn = item; Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(shulkerToReturn); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); } else if (order.isSameItem(item) && Order.isBundle(item.getType()) && totalDeliverable[0] < remaining) { int add = item.getAmount(); if (totalDeliverable[0] + add > remaining) { ItemStack extra = item.clone(); extra.setAmount(totalDeliverable[0] + add - remaining); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(extra); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); add = remaining - totalDeliverable[0]; } org.bukkit.inventory.meta.BundleMeta bm = (org.bukkit.inventory.meta.BundleMeta) item.getItemMeta(); if (bm != null) { for (ItemStack inside : bm.getItems()) { if (inside == null || inside.getType() == Material.AIR) continue; final ItemStack insideCopy = inside.clone(); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(insideCopy); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); } } totalDeliverable[0] += add; } else if (Order.isBundle(item.getType()) && !order.isSameItem(item)) { org.bukkit.inventory.meta.BundleMeta bundleMeta = (org.bukkit.inventory.meta.BundleMeta) item.getItemMeta(); if (bundleMeta != null) { java.util.List bundleItems = new java.util.ArrayList<>(bundleMeta.getItems()); java.util.List toReturn = new java.util.ArrayList<>(); for (ItemStack inside : bundleItems) { if (inside == null || inside.getType() == Material.AIR) continue; if (order.isSameItem(inside) && totalDeliverable[0] < remaining) { int add = inside.getAmount(); if (totalDeliverable[0] + add > remaining) { ItemStack extra = inside.clone(); extra.setAmount(totalDeliverable[0] + add - remaining); toReturn.add(extra); add = remaining - totalDeliverable[0]; } totalDeliverable[0] += add; } else { toReturn.add(inside); } } bundleMeta.setItems(toReturn); item.setItemMeta(bundleMeta); final ItemStack toReturnBundle = item; Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(toReturnBundle); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); } } else if (order.isSameItem(item) && totalDeliverable[0] < remaining) { int add = item.getAmount(); if (totalDeliverable[0] + add > remaining) { ItemStack extra = item.clone(); extra.setAmount(totalDeliverable[0] + add - remaining); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(extra); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); add = remaining - totalDeliverable[0]; } totalDeliverable[0] += add; } else { final ItemStack unrelated = item; Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { java.util.Map leftover = deliveringPlayer.getInventory().addItem(unrelated); for (ItemStack drop : leftover.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); }); } } if (totalDeliverable[0] > 0) { double money = (double) totalDeliverable[0] * order.getPrice(); Material mat = Material.getMaterial(order.getMaterialName()); if (mat == null) throw new NullPointerException("DeliveringMaterial is null"); connection.setAutoCommit(false); try { updateOrderStmt.setInt(1, totalDeliverable[0]); updateOrderStmt.setInt(2, totalDeliverable[0]); updateOrderStmt.setInt(3, order.getId()); updateOrderStmt.executeUpdate(); connection.commit(); } catch (SQLException e) { connection.rollback(); connection.setAutoCommit(true); final int finalTotal = totalDeliverable[0]; Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { for (ItemStack item : deliveringItems) { if (item == null || item.getType() == Material.AIR) continue; java.util.Map lo = deliveringPlayer.getInventory().addItem(item); for (ItemStack drop : lo.values()) deliveringPlayer.getWorld().dropItemNaturally(deliveringPlayer.getLocation(), drop); } }); throw e; } connection.setAutoCommit(true); HooksManager.getCurrency().giveBalance(deliveringPlayer, money); String rawMsg = LangConfig.getRawString("send-delivery-message"); Function fmt = LangConfig.Formatters.combine( LangConfig.Formatters.forAmount(totalDeliverable[0]), LangConfig.Formatters.forItem(mat), LangConfig.Formatters.forMoney(money)); String deliveryMsg = LangConfig.translateColors(fmt.apply(rawMsg)); deliveringPlayer.sendMessage(deliveryMsg); LangConfig.sendActionBar(deliveringPlayer, deliveryMsg); DiscordWebhook.sendOrderDelivered(deliveringPlayer.getName(), order.getPlayer(), StringUtils.materialToString(new org.bukkit.inventory.ItemStack(mat)), totalDeliverable[0], order.getPrice()); if (onSuccess != null) Bukkit.getScheduler().runTask(DonutOrders.plugin, onSuccess); Player recv = Bukkit.getPlayer(order.getPlayer()); if (recv != null && recv.isOnline()) { if (NotificationManager.isEnabled(recv.getName())) { String recvMsg = LangConfig.translateColors(LangConfig.getRawString("receive-delivery-message") .replace("%player%", deliveringPlayer.getName()) .replace("%amount%", StringUtils.formatedAmount(totalDeliverable[0])) .replace("%item%", StringUtils.materialToString(order.toItemStack()))); recv.sendMessage(recvMsg); LangConfig.sendActionBar(recv, recvMsg); recv.playSound(recv, org.bukkit.Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1.0F, 1.0F); } } else { String recvMsg = LangConfig.translateColors(LangConfig.getRawString("receive-delivery-offline-message") .replace("%player%", deliveringPlayer.getName()) .replace("%amount%", StringUtils.formatedAmount(totalDeliverable[0])) .replace("%item%", StringUtils.materialToString(order.toItemStack()))); try (java.sql.PreparedStatement notifStmt = connection.prepareStatement( "INSERT INTO pending_notifications (Player, Message) VALUES (?, ?)")) { notifStmt.setString(1, order.getPlayer()); notifStmt.setString(2, recvMsg); notifStmt.executeUpdate(); } } boolean isComplete = (rs.getInt("DeliveredAmount") + totalDeliverable[0]) >= rs.getInt("Amount"); if (isComplete) { try (PreparedStatement setDate = connection.prepareStatement( "UPDATE orders SET CompletedDate = ? WHERE Id = ?")) { setDate.setString(1, OrderUtils.getCurrentDateTime()); setDate.setInt(2, order.getId()); setDate.executeUpdate(); } String orderPlayer = order.getPlayer(); String materialName = order.getMaterialName(); Player orderOwner = Bukkit.getPlayer(orderPlayer); if (orderOwner != null && orderOwner.isOnline()) { if (!NotificationManager.isEnabled(orderOwner.getName())) return; Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> { String msg = LangConfig.translateColors(LangConfig.getRawString("order-complete-message") .replace("%item%", StringUtils.materialToString(order.toItemStack()))); orderOwner.sendMessage(msg); LangConfig.sendActionBar(orderOwner, msg); SoundConfig.play(orderOwner, "sounds.order-complete-notification"); }); } else { String completeMsg = LangConfig.translateColors(LangConfig.getRawString("order-complete-message") .replace("%item%", StringUtils.materialToString(order.toItemStack()))); try (java.sql.PreparedStatement notifStmt = connection.prepareStatement( "INSERT INTO pending_notifications (Player, Message) VALUES (?, ?)")) { notifStmt.setString(1, orderPlayer); notifStmt.setString(2, completeMsg); notifStmt.executeUpdate(); } } } } } } catch (SQLException e) { e.printStackTrace(); Bukkit.getScheduler().runTask(DonutOrders.plugin, () -> deliveringPlayer.sendMessage("Error processing delivery for Order ID: " + order.getId())); } }); } public void addCollectedAmountById(int orderId, int collectedAmount) { DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { try (Connection connection = this.databaseManager.getConnection()) { connection.setAutoCommit(false); try { try (PreparedStatement p = connection.prepareStatement( "UPDATE orders SET CollectedAmount = MIN(CollectedAmount + ?, DeliveredAmount) WHERE Id = ?")) { p.setInt(1, collectedAmount); p.setInt(2, orderId); p.executeUpdate(); } try (PreparedStatement p = connection.prepareStatement( "DELETE FROM orders WHERE Id = ? AND IsActive = 0 AND DeliveredAmount = CollectedAmount")) { p.setInt(1, orderId); p.executeUpdate(); } connection.commit(); } catch (SQLException e) { connection.rollback(); e.printStackTrace(); } finally { connection.setAutoCommit(true); } } catch (SQLException e) { e.printStackTrace(); } }); } private List extractOrdersFromResultSet(ResultSet rs, boolean ignoreTime) throws SQLException { List orders = new ArrayList<>(), expiredOrders = new ArrayList<>(); while (rs.next()) { Order order = this.extractOrderFromResultSet(rs); if (order.timeLeft() > 0) orders.add(order); else { expiredOrders.add(order); if (ignoreTime) orders.add(order); } } DonutOrders.plugin.getServer().getAsyncScheduler().runNow(DonutOrders.plugin, _task -> { List active = expiredOrders.stream().filter(Order::isActive).collect(Collectors.toList()); if (!active.isEmpty()) this.disableOrDeleteOrdersBatch(Bukkit.getOfflinePlayer(active.get(0).getPlayer()), active, null); }); return orders; } private Order extractOrderFromResultSet(ResultSet rs) throws SQLException { Order order = new Order(); order.setId(rs.getInt("Id")); order.setMaterialName(rs.getString("Material")); order.setPlayer(rs.getString("Player")); order.setPrice(rs.getDouble("Price")); order.setAmount(rs.getInt("Amount")); order.setDeliveredAmount(rs.getInt("DeliveredAmount")); order.setCollectedAmount(rs.getInt("CollectedAmount")); order.setProperties(rs.getString("Properties")); order.setActive(rs.getInt("IsActive")); order.setDate(rs.getString("Date")); try { order.setCompletedDate(rs.getString("CompletedDate")); } catch (java.sql.SQLException e) { order.setCompletedDate(null); } return order; } }