Init

src/main/java/systems/brn/servershop/ItemPrice.java

@@ -0,0 +1,6 @@
+package systems.brn.servershop;
+
+public record ItemPrice(
+        int buyPrice, int sellPrice
+) {
+}

src/main/java/systems/brn/servershop/ServerShop.java

@@ -0,0 +1,124 @@
+package systems.brn.servershop;
+
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.LongArgumentType;
+import eu.pb4.polymer.resourcepack.api.PolymerResourcePackUtils;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.minecraft.command.CommandRegistryAccess;
+import net.minecraft.command.argument.EntityArgumentType;
+import net.minecraft.command.argument.ItemStackArgumentType;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.command.CommandManager;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayNetworkHandler;
+import net.minecraft.server.network.ServerPlayerEntity;
+import systems.brn.servershop.commands.*;
+import systems.brn.servershop.lib.BalanceManager;
+import systems.brn.servershop.lib.PriceStorage;
+
+import java.util.HashMap;
+
+import static net.minecraft.server.command.CommandManager.argument;
+import static net.minecraft.server.command.CommandManager.literal;
+
+public class ServerShop implements ModInitializer {
+
+    public static PriceStorage priceStorage = null;
+    public static BalanceManager balanceManager = null;
+    public static final String MOD_ID = "servershop";
+    public static final HashMap<ServerPlayerEntity, Integer> balances = new HashMap<>();
+
+    @Override
+    public void onInitialize() {
+        ServerLifecycleEvents.SERVER_STARTED.register(this::onServerStarted);
+        ServerLifecycleEvents.SERVER_STOPPED.register(this::onServerStopped);
+        CommandRegistrationCallback.EVENT.register(this::commandRegister);
+
+        ServerPlayConnectionEvents.JOIN.register(this::onPlayerJoin);
+
+        PolymerResourcePackUtils.addModAssets(MOD_ID);
+        PolymerResourcePackUtils.markAsRequired();
+    }
+
+    private void onPlayerJoin(ServerPlayNetworkHandler serverPlayNetworkHandler, PacketSender packetSender, MinecraftServer server) {
+        if (packetSender instanceof ServerPlayerEntity player) {
+            balanceManager.onJoin(player);
+        }
+    }
+
+    private void commandRegister(CommandDispatcher<ServerCommandSource> dispatcher, CommandRegistryAccess commandRegistryAccess, CommandManager.RegistrationEnvironment registrationEnvironment) {
+        dispatcher.register(
+                literal("shop")
+                        .executes(ShopCommand::run));
+        dispatcher.register(
+                literal("pay")
+                        .then(argument("recipient", EntityArgumentType.player())
+                                .then(argument("amount", IntegerArgumentType.integer(1)))
+                        )
+                        .executes(PayCommand::run)
+        );
+        dispatcher.register(
+                literal("balance")
+                        .then(argument("recipient", EntityArgumentType.player()
+                                )
+                                        .requires(serverCommandSource -> serverCommandSource.hasPermissionLevel(2))
+                                        .executes(BalanceCommand::others)
+
+                        )
+                        .then(literal("set")
+                                .requires(serverCommandSource -> serverCommandSource.hasPermissionLevel(2))
+                                .then(argument("balance", LongArgumentType.longArg(1))
+                                        .executes(BalanceCommand::selfSet)
+                                        .then(argument("recipient", EntityArgumentType.player())
+                                                .executes(BalanceCommand::othersSet))
+                                )
+                        )
+                        .executes(BalanceCommand::self)
+        );
+        dispatcher.register(literal("shopprices")
+                .requires(serverCommandSource -> serverCommandSource.hasPermissionLevel(2))
+                .then(literal("load").executes(ShopPricesCommand::load))
+                .then(literal("save").executes(ShopPricesCommand::save))
+                .then(literal("reset").executes(ShopPricesCommand::reset))
+                .then(literal("set")
+                        .then(argument("item", ItemStackArgumentType.itemStack(commandRegistryAccess))
+                                .then(argument("buyprice", IntegerArgumentType.integer())
+                                        .then(argument("sellprice", IntegerArgumentType.integer())
+                                                .executes(ShopPricesCommand::set)
+                                        )
+                                )
+                        )
+                )
+        );
+
+        dispatcher.register(literal("buy")
+                .then(argument("item", ItemStackArgumentType.itemStack(commandRegistryAccess))
+                        .then(argument("count", IntegerArgumentType.integer())
+                                .executes(StoreCommands::buyCount))
+                        .executes(StoreCommands::buyOne)
+                )
+        );
+        dispatcher.register(literal("sell")
+                .then(argument("item", ItemStackArgumentType.itemStack(commandRegistryAccess))
+                        .then(argument("count", IntegerArgumentType.integer())
+                                .executes(StoreCommands::sellCount))
+                        .executes(StoreCommands::sellOne)
+                )
+        );
+
+    }
+
+    private void onServerStarted(MinecraftServer server) {
+        priceStorage = new PriceStorage(server);
+        balanceManager = new BalanceManager(server);
+    }
+
+    private void onServerStopped(MinecraftServer server) {
+        balanceManager.saveBalance();
+    }
+}

src/main/java/systems/brn/servershop/commands/BalanceCommand.java

@@ -0,0 +1,70 @@
+package systems.brn.servershop.commands;
+
+import com.mojang.brigadier.arguments.LongArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import net.minecraft.command.argument.EntityArgumentType;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import static systems.brn.servershop.ServerShop.balanceManager;
+
+public class BalanceCommand {
+    public static int others(CommandContext<ServerCommandSource> ctx) {
+        try {
+            ServerCommandSource playerObj = ctx.getSource();
+            ServerPlayerEntity player = ctx.getSource().getPlayer();
+            ServerPlayerEntity target = EntityArgumentType.getPlayer(ctx, "recipient");
+            if (player != null && target != null) {
+                long senderBalance = balanceManager.getBalance(target);
+                playerObj.sendFeedback(() -> Text.translatable("message.servershop.balance.other", target.getName(), senderBalance), false);
+            }
+        } catch (Exception ignored) {
+            return 1;
+        }
+        return 0;
+    }
+
+    public static int self(CommandContext<ServerCommandSource> ctx) {
+        try {
+            ServerCommandSource playerObj = ctx.getSource();
+            ServerPlayerEntity player = ctx.getSource().getPlayer();
+            if (player != null) {
+                long senderBalance = balanceManager.getBalance(player);
+                playerObj.sendFeedback(() -> Text.translatable("message.servershop.balance.self", senderBalance), false);
+            }
+        } catch (Exception ignored) {
+            return 1;
+        }
+        return 0;
+    }
+
+    public static int selfSet(CommandContext<ServerCommandSource> ctx) {
+        try {
+            ServerPlayerEntity player = ctx.getSource().getPlayer();
+            long senderBalance = LongArgumentType.getLong(ctx, "balance");
+            if (player != null) {
+                balanceManager.setBalance(player, senderBalance);
+            }
+        } catch (Exception ignored) {
+            return 1;
+        }
+        return 0;
+    }
+
+    public static int othersSet(CommandContext<ServerCommandSource> ctx) {
+        try {
+            ServerCommandSource playerObj = ctx.getSource();
+            ServerPlayerEntity player = ctx.getSource().getPlayer();
+            long senderBalance = LongArgumentType.getLong(ctx, "balance");
+            ServerPlayerEntity target = EntityArgumentType.getPlayer(ctx, "recipient");
+            if (player != null && target != null) {
+                balanceManager.setBalance(target, senderBalance);
+                playerObj.sendFeedback(() -> Text.translatable("message.servershop.balance.set_other", target.getName(), senderBalance), false);
+            }
+        } catch (Exception ignored) {
+            return 1;
+        }
+        return 0;
+    }
+}

src/main/java/systems/brn/servershop/commands/PayCommand.java

@@ -0,0 +1,34 @@
+package systems.brn.servershop.commands;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import net.minecraft.command.argument.EntityArgumentType;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import static systems.brn.servershop.ServerShop.balanceManager;
+
+public class PayCommand {
+    public static int run(CommandContext<ServerCommandSource> ctx) {
+        try {
+            ServerCommandSource senderObj = ctx.getSource();
+            ServerPlayerEntity sender = ctx.getSource().getPlayer();
+            ServerPlayerEntity target = EntityArgumentType.getPlayer(ctx, "recipient");
+            int amount = IntegerArgumentType.getInteger(ctx, "amount");
+            if (sender != null) {
+                long senderBalance = balanceManager.getBalance(sender);
+                if (senderBalance >= amount && amount > 0) {
+                    balanceManager.removeBalance(sender, amount);
+                    balanceManager.addBalance(target, amount);
+                    senderObj.sendFeedback(() -> Text.translatable("message.servershop.pay.success", amount, target.getName(), senderBalance), false);
+                } else {
+                    senderObj.sendFeedback(() -> Text.translatable("message.servershop.pay.bad_amount", amount, senderBalance), false);
+                }
+            }
+            return 0;
+        } catch (Exception ignored) {
+            return 1;
+        }
+    }
+}

src/main/java/systems/brn/servershop/commands/ShopCommand.java

@@ -0,0 +1,15 @@
+package systems.brn.servershop.commands;
+
+import com.mojang.brigadier.context.CommandContext;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayerEntity;
+import systems.brn.servershop.screens.ShopScreen;
+
+public class ShopCommand {
+    public static int run(CommandContext<ServerCommandSource> serverCommandSourceCommandContext) {
+        ServerPlayerEntity player = serverCommandSourceCommandContext.getSource().getPlayer();
+        ShopScreen shopScreen = new ShopScreen(player);
+        shopScreen.open();
+        return 0;
+    }
+}

src/main/java/systems/brn/servershop/commands/ShopPricesCommand.java

@@ -0,0 +1,45 @@
+package systems.brn.servershop.commands;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import net.minecraft.command.argument.ItemStackArgumentType;
+import net.minecraft.item.Item;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.text.Text;
+import systems.brn.servershop.ServerShop;
+
+public class ShopPricesCommand {
+    public static int load(CommandContext<ServerCommandSource> ctx) {
+        ServerShop.priceStorage.load();
+        ctx.getSource().sendFeedback(() -> Text.translatable("message.servershop.storage.load"), false);
+        return 1;
+    }
+
+    public static int save(CommandContext<ServerCommandSource> ctx) {
+        boolean success = ServerShop.priceStorage.save();
+        ctx.getSource().sendFeedback(() ->
+                Text.translatable(success ? "message.servershop.storage.save" : "message.servershop.storage.save_fail"), false);
+        return 1;
+    }
+
+    public static int reset(CommandContext<ServerCommandSource> ctx) {
+        ServerShop.priceStorage.generateEmpty();
+        ctx.getSource().sendFeedback(() -> Text.translatable("message.servershop.storage.reset"), false);
+        return 1;
+    }
+
+    public static int set(CommandContext<ServerCommandSource> ctx) {
+        Item item = ItemStackArgumentType.getItemStackArgument(ctx, "item").getItem();
+        int buyPrice = IntegerArgumentType.getInteger(ctx, "buyprice");
+        int sellPrice = IntegerArgumentType.getInteger(ctx, "sellprice");
+        String itemName = item.toString();
+        boolean success = ServerShop.priceStorage.setPrices(item, buyPrice, sellPrice);
+        if (success) {
+            ctx.getSource().sendFeedback(() -> Text.translatable("message.servershop.storage.set", itemName, buyPrice, sellPrice), false);
+            return 1;
+        } else {
+            ctx.getSource().sendFeedback(() -> Text.translatable("message.servershop.storage.set_fail", itemName), false);
+            return 0;
+        }
+    }
+}

src/main/java/systems/brn/servershop/commands/StoreCommands.java

@@ -0,0 +1,60 @@
+package systems.brn.servershop.commands;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import net.minecraft.command.argument.ItemStackArgumentType;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayerEntity;
+
+import static systems.brn.servershop.lib.ShopFunctions.buy;
+import static systems.brn.servershop.lib.ShopFunctions.sell;
+
+public class StoreCommands {
+    public static int buyCount(CommandContext<ServerCommandSource> ctx) {
+        Item item = ItemStackArgumentType.getItemStackArgument(ctx, "item").getItem();
+        int count = IntegerArgumentType.getInteger(ctx, "count");
+        ItemStack itemStack = new ItemStack(item, count);
+        ServerPlayerEntity player = ctx.getSource().getPlayer();
+        if (player != null) {
+            buy(itemStack, player);
+            return 0;
+        }
+        return 1;
+    }
+
+    public static int buyOne(CommandContext<ServerCommandSource> ctx) {
+        Item item = ItemStackArgumentType.getItemStackArgument(ctx, "item").getItem();
+        ItemStack itemStack = new ItemStack(item);
+        ServerPlayerEntity player = ctx.getSource().getPlayer();
+        if (player != null) {
+            buy(itemStack, player);
+            return 0;
+        }
+        return 1;
+    }
+
+    public static int sellCount(CommandContext<ServerCommandSource> ctx) {
+        Item item = ItemStackArgumentType.getItemStackArgument(ctx, "item").getItem();
+        int count = IntegerArgumentType.getInteger(ctx, "count");
+        ItemStack itemStack = new ItemStack(item, count);
+        ServerPlayerEntity player = ctx.getSource().getPlayer();
+        if (player != null) {
+            sell(itemStack, player);
+            return 0;
+        }
+        return 1;
+    }
+
+    public static int sellOne(CommandContext<ServerCommandSource> ctx) {
+        Item item = ItemStackArgumentType.getItemStackArgument(ctx, "item").getItem();
+        ItemStack itemStack = new ItemStack(item);
+        ServerPlayerEntity player = ctx.getSource().getPlayer();
+        if (player != null) {
+            sell(itemStack, player);
+            return 0;
+        }
+        return 1;
+    }
+}

src/main/java/systems/brn/servershop/lib/BalanceManager.java

@@ -0,0 +1,121 @@
+package systems.brn.servershop.lib;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import net.minecraft.util.WorldSavePath;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.UUID;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class BalanceManager {
+    final private HashMap<UUID, Long> balances = new HashMap<>();
+    public final MinecraftServer server;
+    public final File balanceStorageFile;
+    private static final ReentrantLock lock = new ReentrantLock();  // Lock for in-memory operations
+
+    public BalanceManager(MinecraftServer server) {
+        this.server = server;
+        balanceStorageFile = server.getSavePath(WorldSavePath.ROOT).resolve("balances.csv").toFile();
+        loadBalance();
+    }
+
+    public long getBalance(UUID uuid) {
+        if (balances.containsKey(uuid)) {
+            return balances.get(uuid);
+        }
+        return 0L;
+    }
+
+    public long getBalance(ServerPlayerEntity player) {
+        return getBalance(player.getUuid());
+    }
+
+    public void addBalance(UUID uuid, long amount) {
+        balances.put(uuid, amount + getBalance(uuid));
+        saveBalance();
+    }
+
+    public void addBalance(ServerPlayerEntity player, long amount) {
+        addBalance(player.getUuid(), amount);
+        announceBalance(player, true);
+    }
+
+    public void removeBalance(UUID uuid, long amount) {
+        balances.put(uuid, getBalance(uuid) - amount);
+        saveBalance();
+    }
+
+    public void setBalance(UUID uuid, long amount) {
+        balances.put(uuid, getBalance(uuid) + amount);
+    }
+
+    public void setBalance(ServerPlayerEntity player, long amount) {
+        setBalance(player.getUuid(), amount);
+        announceBalance(player, true);
+    }
+
+    public void removeBalance(ServerPlayerEntity player, long amount) {
+        removeBalance(player.getUuid(), amount);
+        announceBalance(player, true);
+    }
+
+    public boolean saveBalance() {
+        lock.lock();
+        try {
+            FileWriter fileWriter = new FileWriter(balanceStorageFile, false);
+            for (UUID uuid : balances.keySet()) {
+                long balance = getBalance(uuid);
+                fileWriter.write(uuid.toString() + "," + balance + "\n");
+            }
+            fileWriter.close();
+            lock.unlock();
+        } catch (IOException e) {
+            lock.unlock();
+            return false;
+        }
+        return true;
+    }
+
+    public void onJoin(ServerPlayerEntity player) {
+        UUID uuid = player.getUuid();
+        if (!balances.containsKey(uuid)) {
+            balances.put(uuid, 0L);
+        }
+    }
+
+    public void loadBalance() {
+        lock.lock();
+        if (!balances.isEmpty()) {
+            balances.clear();
+        }
+        try {
+            Scanner scanner = new Scanner(balanceStorageFile);
+            while (scanner.hasNextLine()) {
+                String line = scanner.nextLine();
+                String[] lineParts = line.split(",");
+                if (lineParts.length == 2) {
+                    UUID uuid = UUID.fromString(lineParts[0]);
+                    Long amount = Long.parseLong(lineParts[1]);
+                    balances.put(uuid, amount);
+                }
+            }
+
+        } catch (FileNotFoundException ignored) {
+            saveBalance();
+        }
+        lock.unlock();
+    }
+
+    public void announceBalance(ServerPlayerEntity player, boolean overlay) {
+        UUID uuid = player.getUuid();
+        long balance = balances.getOrDefault(uuid, 0L);
+        player.sendMessage(Text.translatable("message.servershop.balance.self", balance), overlay);
+    }
+}

src/main/java/systems/brn/servershop/lib/PagedGui.java

@@ -0,0 +1,202 @@
+package systems.brn.servershop.lib;
+
+import eu.pb4.sgui.api.elements.GuiElement;
+import eu.pb4.sgui.api.elements.GuiElementBuilder;
+import eu.pb4.sgui.api.elements.GuiElementBuilderInterface;
+import eu.pb4.sgui.api.elements.GuiElementInterface;
+import eu.pb4.sgui.api.gui.SimpleGui;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.screen.ScreenHandlerType;
+import net.minecraft.screen.slot.Slot;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+
+//from https://github.com/Patbox/get-off-my-lawn-reserved/blob/6c03c6b004f65616d1d8cb773c19da970eb8c1d1/src/main/java/draylar/goml/ui/PagedGui.java
+@ApiStatus.Internal
+public abstract class PagedGui extends SimpleGui {
+
+    public static final String GUI_PREVIOUS_PAGE = "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMzEwODI5OGZmMmIyNjk1MWQ2ODNlNWFkZTQ2YTQyZTkwYzJmN2M3ZGQ0MWJhYTkwOGJjNTg1MmY4YzMyZTU4MyJ9fX0";
+    public static final String GUI_PREVIOUS_PAGE_BLOCKED = "ewogICJ0aW1lc3RhbXAiIDogMTY0MDYxNjE5MjE0MiwKICAicHJvZmlsZUlkIiA6ICJmMjc0YzRkNjI1MDQ0ZTQxOGVmYmYwNmM3NWIyMDIxMyIsCiAgInByb2ZpbGVOYW1lIiA6ICJIeXBpZ3NlbCIsCiAgInNpZ25hdHVyZVJlcXVpcmVkIiA6IHRydWUsCiAgInRleHR1cmVzIiA6IHsKICAgICJTS0lOIiA6IHsKICAgICAgInVybCIgOiAiaHR0cDovL3RleHR1cmVzLm1pbmVjcmFmdC5uZXQvdGV4dHVyZS81MDgyMGY3NmUzZTA0MWM3NWY3NmQwZjMwMTIzMmJkZjQ4MzIxYjUzNGZlNmE4NTljY2I4NzNkMjk4MWE5NjIzIiwKICAgICAgIm1ldGFkYXRhIiA6IHsKICAgICAgICAibW9kZWwiIDogInNsaW0iCiAgICAgIH0KICAgIH0KICB9Cn0=";
+    public static final String GUI_NEXT_PAGE = "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzg2MTg1YjFkNTE5YWRlNTg1ZjE4NGMzNGYzZjNlMjBiYjY0MWRlYjg3OWU4MTM3OGU0ZWFmMjA5Mjg3In19fQ";
+    public static final String GUI_NEXT_PAGE_BLOCKED = "ewogICJ0aW1lc3RhbXAiIDogMTY0MDYxNjExMDQ4OCwKICAicHJvZmlsZUlkIiA6ICIxZjEyNTNhYTVkYTQ0ZjU5YWU1YWI1NmFhZjRlNTYxNyIsCiAgInByb2ZpbGVOYW1lIiA6ICJOb3RNaUt5IiwKICAic2lnbmF0dXJlUmVxdWlyZWQiIDogdHJ1ZSwKICAidGV4dHVyZXMiIDogewogICAgIlNLSU4iIDogewogICAgICAidXJsIiA6ICJodHRwOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlLzdlNTc3MjBhNDg3OGM4YmNhYjBlOWM5YzQ3ZDllNTUxMjhjY2Q3N2JhMzQ0NWE1NGE5MWUzZTFlMWEyNzM1NmUiLAogICAgICAibWV0YWRhdGEiIDogewogICAgICAgICJtb2RlbCIgOiAic2xpbSIKICAgICAgfQogICAgfQogIH0KfQ==";
+    public static final String GUI_QUESTION_MARK = "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmM4ZWExZjUxZjI1M2ZmNTE0MmNhMTFhZTQ1MTkzYTRhZDhjM2FiNWU5YzZlZWM4YmE3YTRmY2I3YmFjNDAifX19";
+
+    public static final int PAGE_SIZE = 9 * 5;
+    protected final Runnable closeCallback;
+    public boolean ignoreCloseCallback;
+
+    public int page = 0;
+
+    public PagedGui(ServerPlayerEntity player, @Nullable Runnable closeCallback) {
+        super(ScreenHandlerType.GENERIC_9X6, player, false);
+        this.closeCallback = closeCallback;
+    }
+
+    @Override
+    public void onClose() {
+        if (this.closeCallback != null && !ignoreCloseCallback) {
+            this.closeCallback.run();
+        }
+    }
+
+    protected void nextPage() {
+        this.page = Math.min(this.getPageAmount() - 1, this.page + 1);
+        this.updateDisplay();
+    }
+
+    protected boolean canNextPage() {
+        return this.getPageAmount() > this.page + 1;
+    }
+
+    protected void previousPage() {
+        this.page = Math.max(0, this.page - 1);
+        this.updateDisplay();
+    }
+
+    protected boolean canPreviousPage() {
+        return this.page - 1 >= 0;
+    }
+
+    public void updateDisplay() {
+        var offset = page * PAGE_SIZE;
+
+        for (int i = 0; i < PAGE_SIZE; i++) {
+            var element = this.getElement(offset + i);
+
+            if (element == null) {
+                element = DisplayElement.empty();
+            }
+
+            if (element.element() != null) {
+                this.setSlot(i, element.element());
+            } else if (element.slot() != null) {
+                this.setSlotRedirect(i, element.slot());
+            }
+        }
+
+        for (int i = 0; i < 9; i++) {
+            var navElement = this.getNavElement(i);
+
+            if (navElement == null) {
+                navElement = DisplayElement.EMPTY;
+            }
+
+            if (navElement.element != null) {
+                this.setSlot(i + PAGE_SIZE, navElement.element);
+            } else if (navElement.slot != null) {
+                this.setSlotRedirect(i + PAGE_SIZE, navElement.slot);
+            }
+        }
+    }
+
+    protected abstract int getPageAmount();
+
+    protected abstract DisplayElement getElement(int id);
+
+    protected DisplayElement getNavElement(int id) {
+        return switch (id) {
+            case 0 -> DisplayElement.previousPage(this);
+            case 1 -> this.search();
+            case 7 -> DisplayElement.nextPage(this);
+            case 8 -> DisplayElement.of(
+                    new GuiElementBuilder(Items.STRUCTURE_VOID)
+                            .setName(Text.translatable(this.closeCallback != null ? "gui.back" : "mco.selectServer.close").formatted(Formatting.RED))
+                            .hideDefaultTooltip().noDefaults()
+                            .setCallback((i, clickType, slotActionType) -> {
+                                playClickSound(this.player);
+                                this.close();
+                            })
+            );
+            default -> DisplayElement.filler();
+        };
+    }
+
+    protected DisplayElement search(){
+        return DisplayElement.filler();
+    }
+
+
+    public record DisplayElement(@Nullable GuiElementInterface element, @Nullable Slot slot) {
+        private static final DisplayElement EMPTY = DisplayElement.of(new GuiElement(ItemStack.EMPTY, GuiElementInterface.EMPTY_CALLBACK));
+        private static final DisplayElement FILLER = DisplayElement.of(
+                new GuiElementBuilder(Items.WHITE_STAINED_GLASS_PANE)
+                        .setName(Text.empty())
+                        .hideTooltip()
+        );
+
+        public static DisplayElement of(GuiElementInterface element) {
+            return new DisplayElement(element, null);
+        }
+
+        public static DisplayElement of(GuiElementBuilderInterface<?> element) {
+            return new DisplayElement(element.build(), null);
+        }
+
+        public static DisplayElement of(Slot slot) {
+            return new DisplayElement(null, slot);
+        }
+
+        public static DisplayElement nextPage(PagedGui gui) {
+            if (gui.canNextPage()) {
+                return DisplayElement.of(
+                        new GuiElementBuilder(Items.PLAYER_HEAD)
+                                .setName(Text.translatable("createWorld.customize.custom.next").formatted(Formatting.WHITE))
+                                .hideDefaultTooltip().noDefaults()
+                                .setSkullOwner(GUI_NEXT_PAGE)
+                                .setCallback((x, y, z) -> {
+                                    playClickSound(gui.player);
+                                    gui.nextPage();
+                                })
+                );
+            } else {
+                return DisplayElement.of(
+                        new GuiElementBuilder(Items.PLAYER_HEAD)
+                                .setName(Text.translatable("createWorld.customize.custom.next").formatted(Formatting.DARK_GRAY))
+                                .hideDefaultTooltip().noDefaults()
+                                .setSkullOwner(GUI_NEXT_PAGE_BLOCKED)
+                );
+            }
+        }
+
+        public static DisplayElement previousPage(PagedGui gui) {
+            if (gui.canPreviousPage()) {
+                return DisplayElement.of(
+                        new GuiElementBuilder(Items.PLAYER_HEAD)
+                                .setName(Text.translatable("createWorld.customize.custom.prev").formatted(Formatting.WHITE))
+                                .hideDefaultTooltip().noDefaults()
+                                .setSkullOwner(GUI_PREVIOUS_PAGE)
+                                .setCallback((x, y, z) -> {
+                                    playClickSound(gui.player);
+                                    gui.previousPage();
+                                })
+                );
+            } else {
+                return DisplayElement.of(
+                        new GuiElementBuilder(Items.PLAYER_HEAD)
+                                .setName(Text.translatable("createWorld.customize.custom.prev").formatted(Formatting.DARK_GRAY))
+                                .hideDefaultTooltip().noDefaults()
+                                .setSkullOwner(GUI_PREVIOUS_PAGE_BLOCKED)
+                );
+            }
+        }
+
+        public static DisplayElement filler() {
+            return FILLER;
+        }
+
+        public static DisplayElement empty() {
+            return EMPTY;
+        }
+    }
+
+    public static void playClickSound(ServerPlayerEntity player) {
+        player.playSoundToPlayer(SoundEvents.UI_BUTTON_CLICK.value(), SoundCategory.MASTER, 1, 1);
+    }
+}

src/main/java/systems/brn/servershop/lib/PriceStorage.java

@@ -0,0 +1,94 @@
+package systems.brn.servershop.lib;
+
+import net.minecraft.item.Item;
+import net.minecraft.registry.Registries;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.WorldSavePath;
+import systems.brn.servershop.ItemPrice;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class PriceStorage {
+
+    public final MinecraftServer server;
+    public final File priceStorageFile;
+
+    public PriceStorage(MinecraftServer server) {
+        this.server = server;
+        priceStorageFile = server.getSavePath(WorldSavePath.ROOT).resolve("prices.csv").toFile();
+        load();
+    }
+
+    public final HashMap<Item, ItemPrice> prices = new HashMap<>();
+
+    public void generateEmpty() {
+        if (!prices.isEmpty()) {
+            prices.clear();
+        }
+        for (Item item : Registries.ITEM) {
+            ItemPrice itemPrice = new ItemPrice(0, 0);
+            prices.put(item, itemPrice);
+        }
+    }
+
+    public boolean setPrices(Item item, int buyPrice, int sellPrice) {
+        if (prices.containsKey(item)) {
+            prices.remove(item);
+            prices.put(item, new ItemPrice(buyPrice, sellPrice));
+            return true;
+        }
+        return false;
+    }
+
+    public void load() {
+        if (!prices.isEmpty()) {
+            prices.clear();
+        }
+        try {
+            Scanner scanner = new Scanner(priceStorageFile);
+            while (scanner.hasNextLine()) {
+                String line = scanner.nextLine();
+                String[] lineParts = line.split(",");
+                if (lineParts.length == 3) {
+                    String itemName = lineParts[0];
+                    String[] itemIdentifierParts = itemName.split(":");
+                    if (itemIdentifierParts.length == 2) {
+                        Identifier itemIdentifier = Identifier.of(itemIdentifierParts[0], itemIdentifierParts[1]);
+                        int buyPrice = Integer.parseInt(lineParts[1]);
+                        int sellPrice = Integer.parseInt(lineParts[2]);
+                        Item item = Registries.ITEM.get(itemIdentifier);
+                        prices.put(item, new ItemPrice(buyPrice, sellPrice));
+                    }
+                }
+            }
+
+        } catch (FileNotFoundException ignored) {
+            generateEmpty();
+            save();
+        }
+    }
+
+    public boolean save() {
+        try {
+            FileWriter fileWriter = new FileWriter(priceStorageFile, false);
+            for (Item item : prices.keySet()) {
+                ItemPrice itemPrice = prices.get(item);
+                String itemName = item.toString();
+                int buyPrice = itemPrice.buyPrice();
+                int sellPrice = itemPrice.sellPrice();
+                fileWriter.write(itemName + "," + buyPrice + "," + sellPrice + "\n");
+            }
+            fileWriter.close();
+        } catch (IOException e) {
+            return false;
+        }
+        return true;
+    }
+
+}

src/main/java/systems/brn/servershop/lib/ShopFunctions.java

@@ -0,0 +1,59 @@
+package systems.brn.servershop.lib;
+
+import net.minecraft.command.argument.ItemStackArgumentType;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import systems.brn.servershop.ItemPrice;
+
+import static systems.brn.servershop.ServerShop.balanceManager;
+import static systems.brn.servershop.ServerShop.priceStorage;
+import static systems.brn.servershop.lib.Util.*;
+
+public class ShopFunctions {
+    public static void buy(ItemStack itemStack, ServerPlayerEntity player) {
+        Item item = itemStack.getItem();
+        PlayerInventory playerInventory = player.getInventory();
+        ItemPrice price = priceStorage.prices.getOrDefault(item, new ItemPrice(0, 0));
+        int buyPrice = price.buyPrice() * itemStack.getCount();
+        long playerBalance = balanceManager.getBalance(player);
+        if (buyPrice > 0) {
+            if (playerBalance >= buyPrice) {
+                if (canInsertItemIntoInventory(playerInventory, itemStack.copy()) >= itemStack.getCount()) {
+                    ItemStack remaining = insertStackIntoInventory(playerInventory, itemStack.copy());
+                    int toDeduce = buyPrice - (price.buyPrice() * remaining.getCount());
+                    int boughtCount = itemStack.getCount() - remaining.getCount();
+                    balanceManager.removeBalance(player, toDeduce);
+                    player.sendMessage(Text.translatable("message.servershop.buy.success", boughtCount, itemStack.getName(), toDeduce), true);
+                } else {
+                    player.sendMessage(Text.translatable("message.servershop.buy.inventory"), true);
+                }
+            } else {
+                player.sendMessage(Text.translatable("message.servershop.buy.not_enough", buyPrice, playerBalance, buyPrice - playerBalance), true);
+            }
+        } else {
+            player.sendMessage(Text.translatable("message.servershop.buy.not_available", itemStack.getName()), true);
+        }
+    }
+
+    public static void sell(ItemStack itemStack, ServerPlayerEntity player) {
+        Item item = itemStack.getItem();
+        PlayerInventory playerInventory = player.getInventory();
+        ItemPrice price = priceStorage.prices.getOrDefault(item, new ItemPrice(0, 0));
+        int sellPrice = price.sellPrice();
+        if (sellPrice > 0) {
+            int removed = removeFromInventory(playerInventory, itemStack.copy(), itemStack.getCount());
+            if (removed == 0) {
+                player.sendMessage(Text.translatable("message.servershop.sell.not_enough"), true);
+            }
+            int toAdd = sellPrice * (itemStack.getCount() - removed);
+            int soldCount = itemStack.getCount() - removed;
+            balanceManager.addBalance(player, toAdd);
+            player.sendMessage(Text.translatable("message.servershop.sell.success", soldCount, itemStack.getName(), toAdd), true);
+        } else {
+            player.sendMessage(Text.translatable("message.servershop.sell.not_available", itemStack.getName()), true);
+        }
+    }
+}

src/main/java/systems/brn/servershop/lib/Util.java

@@ -0,0 +1,102 @@
+package systems.brn.servershop.lib;
+
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.inventory.Inventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Identifier;
+import systems.brn.servershop.ServerShop;
+
+public class Util {
+
+    public static Identifier id(String path) {
+        return Identifier.of(ServerShop.MOD_ID, path);
+    }
+
+    public static int canInsertItemIntoInventory(Inventory inventory, ItemStack itemStack) {
+        // Get the player's inventory
+        int maxInsert = 0;
+
+        if (inventory instanceof PlayerInventory playerInventory) {
+            // Iterate through the slots in the player's inventory
+            for (int i = 0; i < playerInventory.main.size(); i++) {
+                ItemStack slotStack = playerInventory.main.get(i);
+                maxInsert = canInsertToStack(slotStack, itemStack, maxInsert);
+            }
+        } else {
+            for (int i = 0; i < inventory.size(); i++) {
+                ItemStack slotStack = inventory.getStack(i);
+                maxInsert = canInsertToStack(slotStack, itemStack, maxInsert);
+            }
+        }
+
+        return maxInsert; // Return the maximum insertion count
+    }
+
+    public static int removeFromInventory(Inventory inventory, ItemStack stackToRemove, int remainingToRemove) {
+        for (int i = 0; i < inventory.size(); i++) {
+            ItemStack slotStack = inventory.getStack(i);
+            if (canCombine(slotStack, stackToRemove)) {
+                int removeAmount = Math.min(slotStack.getCount(), remainingToRemove);
+                slotStack.decrement(removeAmount);
+                remainingToRemove -= removeAmount;
+                inventory.markDirty();
+
+                if (slotStack.isEmpty()) {
+                    inventory.setStack(i, ItemStack.EMPTY);
+                }
+
+                if (remainingToRemove <= 0) {
+                    return remainingToRemove;
+                }
+            }
+        }
+        return remainingToRemove;
+    }
+
+    public static int canInsertToStack(ItemStack stack1, ItemStack stack2, int maxInsert) {
+        if (stack1.isEmpty() || ItemStack.areItemsEqual(stack1, stack2)) {
+            int remainingSpace = stack1.isEmpty() ? stack2.getMaxCount() : stack1.getMaxCount() - stack1.getCount();
+            maxInsert += remainingSpace;
+            // If the maximum insertion count is greater than or equal to the item count, return the item count
+            if (maxInsert >= stack2.getCount()) {
+                return stack2.getCount();
+            }
+        }
+        return maxInsert;
+    }
+
+    public static boolean canCombine(ItemStack stack1, ItemStack stack2) {
+        return !stack1.isEmpty() && stack1.getItem() == stack2.getItem() && ItemStack.areItemsAndComponentsEqual(stack1, stack2);
+    }
+
+    public static ItemStack insertStackIntoInventory(Inventory inventory, ItemStack stack) {
+        // First, try to merge with existing stacks
+        for (int i = 0; i < inventory.size(); i++) {
+            ItemStack slotStack = inventory.getStack(i);
+            if (canCombine(slotStack, stack)) {
+                int transferAmount = Math.min(stack.getCount(), slotStack.getMaxCount() - slotStack.getCount());
+                if (transferAmount > 0) {
+                    slotStack.increment(transferAmount);
+                    stack.decrement(transferAmount);
+                    inventory.markDirty();
+                    if (stack.isEmpty()) {
+                        return ItemStack.EMPTY;
+                    }
+                }
+            }
+        }
+
+        // Next, try to find an empty slot
+        for (int i = 0; i < inventory.size(); i++) {
+            ItemStack slotStack = inventory.getStack(i);
+            if (slotStack.isEmpty()) {
+                inventory.setStack(i, stack.copy());
+                stack.setCount(0);
+                inventory.markDirty();
+                return ItemStack.EMPTY;
+            }
+        }
+
+        return stack;
+    }
+}

src/main/java/systems/brn/servershop/screens/SearchScreen.java

@@ -0,0 +1,26 @@
+package systems.brn.servershop.screens;
+
+import eu.pb4.sgui.api.gui.AnvilInputGui;
+import eu.pb4.sgui.api.gui.SimpleGui;
+
+public class SearchScreen extends AnvilInputGui {
+
+    private final SimpleGui parentScreen;
+
+    public SearchScreen(SimpleGui parentScreen, String defaultText) {
+        super(parentScreen.getPlayer(), parentScreen.getLockPlayerInventory());
+        this.parentScreen = parentScreen;
+        parentScreen.close();
+        this.setDefaultInputValue(defaultText);
+    }
+
+    @Override
+    public void onClose() {
+        super.onClose();
+        parentScreen.open();
+        String query = this.getInput();
+        if (parentScreen instanceof ShopScreen shopScreen) {
+            shopScreen.doSearch(query);
+        }
+    }
+}

src/main/java/systems/brn/servershop/screens/ShopScreen.java

@@ -0,0 +1,144 @@
+package systems.brn.servershop.screens;
+
+import eu.pb4.sgui.api.ClickType;
+import eu.pb4.sgui.api.elements.GuiElementBuilder;
+import eu.pb4.sgui.api.elements.GuiElementInterface;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.LoreComponent;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.screen.slot.SlotActionType;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
+import systems.brn.servershop.ItemPrice;
+import systems.brn.servershop.ServerShop;
+import systems.brn.servershop.lib.PagedGui;
+import systems.brn.servershop.lib.ShopFunctions;
+
+import java.util.*;
+
+import static systems.brn.servershop.ServerShop.balanceManager;
+import static systems.brn.servershop.lib.ShopFunctions.buy;
+import static systems.brn.servershop.lib.ShopFunctions.sell;
+import static systems.brn.servershop.lib.Util.*;
+
+public class ShopScreen extends PagedGui {
+
+    public String searchQuery = "";
+
+    final public HashMap<Item, ItemPrice> filteredPrices = new HashMap<>();
+
+    public ShopScreen(ServerPlayerEntity player) {
+        super(player, null);
+        setTitle(Text.translatable("gui.servershop.shop.title"));
+    }
+
+    @Override
+    public boolean open() {
+        updateDisplay();
+        return super.open();
+    }
+
+    @Override
+    public void updateDisplay() {
+        filterPrices();
+        super.updateDisplay();
+    }
+
+    public void filterPrices() {
+        filteredPrices.clear();
+        for (Item item : ServerShop.priceStorage.prices.keySet()) {
+            String itemName = item.toString();
+            if (itemName.contains(searchQuery)) {
+                ItemPrice price = ServerShop.priceStorage.prices.get(item);
+                if (price.buyPrice() > 0 || price.sellPrice() > 0) {
+                    filteredPrices.put(item, price);
+                }
+            }
+        }
+    }
+
+    public void doSearch(String query) {
+        searchQuery = query;
+        updateDisplay();
+    }
+
+    @Override
+    protected int getPageAmount() {
+        return Math.ceilDivExact(filteredPrices.size(), PAGE_SIZE);
+    }
+
+
+    @Override
+    public boolean onClick(int index, ClickType type, SlotActionType action, GuiElementInterface element) {
+        Item item = element.getItemStack().getItem();
+        ItemStack itemStack = item.getDefaultStack();
+        if (type.shift) {
+            itemStack.setCount(itemStack.getMaxCount());
+        }
+        if (type.isLeft) { //buy
+            buy(itemStack, player);
+
+        } else if (type.isRight) { //sell
+            sell(itemStack, player);
+        }
+        return false;
+    }
+
+    public static ItemStack getItemStack(Map.Entry<Item, ItemPrice> price) {
+        ItemPrice itemPrice = price.getValue();
+        Item item = price.getKey();
+        int buyPrice = itemPrice.buyPrice();
+        int sellPrice = itemPrice.sellPrice();
+        ItemStack stack = item.getDefaultStack();
+        LoreComponent originalLore = stack.getOrDefault(DataComponentTypes.LORE, new LoreComponent(List.of()));
+
+        ArrayList<Text> lore = new ArrayList<>(originalLore.lines());
+        if (buyPrice > 0) {
+            lore.add(Text.translatable("gui.servershop.item.buyprice", buyPrice));
+        }
+        if (sellPrice > 0) {
+            lore.add(Text.translatable("gui.servershop.item.sellprice", sellPrice));
+        }
+        stack.set(DataComponentTypes.LORE, new LoreComponent(lore));
+        return stack;
+    }
+
+    @Override
+    protected DisplayElement getElement(int id) {
+        List<Map.Entry<Item, ItemPrice>> list = new ArrayList<>(filteredPrices.entrySet());
+        if (id < list.size()) {
+            Map.Entry<Item, ItemPrice> itemPriceEntry = list.get(id);
+            ItemStack stack = getItemStack(itemPriceEntry);
+            GuiElementBuilder elementBuilder = new GuiElementBuilder(stack);
+            return DisplayElement.of(elementBuilder);
+
+        }
+        return DisplayElement.filler();
+    }
+
+    @Override
+    protected DisplayElement search() {
+        if (searchQuery == null || searchQuery.isEmpty() || searchQuery.equals("*")) {
+            searchQuery = "Filter not set";
+        }
+        return DisplayElement.of(
+                new GuiElementBuilder(Items.PLAYER_HEAD)
+                        .setName(Text.literal(searchQuery).formatted(Formatting.WHITE))
+                        .hideDefaultTooltip().noDefaults()
+                        .setSkullOwner(GUI_QUESTION_MARK)
+                        .setCallback((x, y, z) -> {
+                            playClickSound(getPlayer());
+                            if (y.isRight) {
+                                doSearch("");
+                            } else if (y.isLeft) {
+                                SearchScreen searchScreen = new SearchScreen(this, "");
+                                searchScreen.open();
+                            }
+                        })
+        );
+    }
+}

src/main/resources/assets/servershop/lang/en_us.json

@@ -0,0 +1,24 @@
+{
+  "gui.servershop.shop.title": "Shop",
+  "gui.servershop.item.buyprice": "Buy for %d",
+  "gui.servershop.item.sellprice": "Sell for %d",
+  "message.servershop.storage.load": "Loaded prices from disk",
+  "message.servershop.storage.save": "Saved prices to disk",
+  "message.servershop.storage.save_fail": "Failed saving prices to disk",
+  "message.servershop.storage.reset": "Reset all prices to 0",
+  "message.servershop.storage.set": "Set price for %s, buy price: is %d and sell price is: %d",
+  "message.servershop.storage.set_fail": "Setting price for %s failed",
+  "message.servershop.pay.success": "You paid %d to %s, now you have %d",
+  "message.servershop.pay.bad_amount": "%d is more than you have(%d), or an invalid amount",
+  "message.servershop.balance.other": "%s has %d on his account",
+  "message.servershop.balance.self": "You have %d on your account",
+  "message.servershop.balance.set_self": "Your balance was set to %d",
+  "message.servershop.balance.set_other": "%s now has %d on his account",
+  "message.servershop.buy.not_enough": "You don't have enough money (%d>%d), you need %d more",
+  "message.servershop.buy.inventory": "You don't have enough inventory space",
+  "message.servershop.buy.success": "You bought %d %s for %d",
+  "message.servershop.buy.not_available": "This item (%s) is not available for buying",
+  "message.servershop.sell.not_enough": "You don't have this item",
+  "message.servershop.sell.success": "You sold %d %s for %d",
+  "message.servershop.sell.not_available": "This item (%s) is not available for sale"
+}

src/main/resources/fabric.mod.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "id": "servershop",
+  "version": "${version}",
+  "name": "ServerShop",
+  "description": "",
+  "authors": [],
+  "contact": {},
+  "license": "MIT",
+  "icon": "assets/servershop/icon.png",
+  "environment": "*",
+  "entrypoints": {
+    "main": [
+      "systems.brn.servershop.ServerShop"
+    ]
+  },
+  "mixins": [
+    "servershop.mixins.json"
+  ],
+  "depends": {
+    "fabricloader": ">=${loader_version}",
+    "fabric": "*",
+    "minecraft": "${minecraft_version}"
+  }
+}

src/main/resources/servershop.mixins.json

@@ -0,0 +1,13 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "systems.brn.servershop.mixin",
+  "compatibilityLevel": "JAVA_21",
+  "mixins": [
+  ],
+  "client": [
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}