Update Guilds

src/main/java/dev/plex/command/sub/AcceptSubCommand.java

@@ -0,0 +1,165 @@
+package dev.plex.command.sub;
+
+import com.google.common.collect.ImmutableList;
+import dev.plex.Guilds;
+import dev.plex.command.SimplePlexCommand;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.guild.Guild;
+import dev.plex.guild.data.GuildRole;
+import dev.plex.guild.data.Member;
+import dev.plex.storage.entity.GuildInviteEntity;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+
+public class AcceptSubCommand extends SimplePlexCommand
+{
+    public AcceptSubCommand()
+    {
+        super(command("accept")
+                .description("Accepts a guild invite")
+                .usage("/guild <command> <guild>")
+                .permission("plex.guilds.accept")
+                .source(RequiredCommandSource.IN_GAME)
+                .build());
+    }
+
+    @Override
+    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+        assert player != null;
+        Guilds.get().getGuildRepository().invitesFor(player.getUniqueId()).whenComplete((invites, throwable) ->
+        {
+            if (throwable != null)
+            {
+                send(player, messageComponent("guildStorageFailed"));
+                return;
+            }
+            GuildInviteEntity invite = findInvite(invites, String.join(" ", args));
+            if (invite == null)
+            {
+                send(player, messageComponent("guildNotValidInvite"));
+                return;
+            }
+            if (invite.getExpiresAt() < Instant.now().toEpochMilli())
+            {
+                Guilds.get().getGuildRepository().deleteInvite(UUID.fromString(invite.getGuildUuid()), player.getUniqueId());
+                send(player, messageComponent("guildInviteExpired"));
+                return;
+            }
+            Guild target = Guilds.get().getGuildHolder().guildById(UUID.fromString(invite.getGuildUuid())).orElse(null);
+            if (target == null)
+            {
+                send(player, messageComponent("guildNotValidInvite"));
+                return;
+            }
+            leaveCurrentIfNeeded(player, target, invite);
+        });
+        return null;
+    }
+
+    private GuildInviteEntity findInvite(List<GuildInviteEntity> invites, String guildName)
+    {
+        return invites.stream()
+                .filter(invite -> Guilds.get().getGuildHolder().guildById(UUID.fromString(invite.getGuildUuid()))
+                        .map(guild -> guild.getName().equalsIgnoreCase(guildName))
+                        .orElse(false))
+                .findFirst()
+                .orElse(null);
+    }
+
+    private void leaveCurrentIfNeeded(Player player, Guild target, GuildInviteEntity invite)
+    {
+        Guilds.get().getGuildHolder().guild(player.getUniqueId()).ifPresentOrElse(current ->
+        {
+            if (current.getGuildUuid().equals(target.getGuildUuid()))
+            {
+                send(player, messageComponent("guildInThis"));
+                return;
+            }
+            if (current.isOwner(player.getUniqueId()) && current.getMembers().size() > 1)
+            {
+                send(player, messageComponent("guildOwnerLeaveBlocked"));
+                return;
+            }
+            if (current.isOwner(player.getUniqueId()))
+            {
+                Guilds.get().getGuildRepository().deleteGuild(current.getGuildUuid()).whenComplete((unused, throwable) ->
+                {
+                    if (throwable != null)
+                    {
+                        send(player, messageComponent("guildStorageFailed"));
+                        return;
+                    }
+                    Guilds.get().getGuildHolder().removeGuild(current.getGuildUuid());
+                    joinTarget(player, target, invite);
+                });
+                return;
+            }
+            Guilds.get().getGuildRepository().removeMember(current.getGuildUuid(), player.getUniqueId()).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                current.getMembers().removeIf(member -> member.getUuid().equals(player.getUniqueId()));
+                Guilds.get().getGuildHolder().unindexMember(player.getUniqueId());
+                current.getMembers().stream().map(Member::getPlayer).filter(Objects::nonNull).forEach(memberPlayer ->
+                        send(memberPlayer, messageComponent("guildMemberLeft", player.getName())));
+                joinTarget(player, target, invite);
+            });
+        }, () -> joinTarget(player, target, invite));
+    }
+
+    private void joinTarget(Player player, Guild guild, GuildInviteEntity invite)
+    {
+        UUID guildUuid = guild.getGuildUuid();
+        Guilds.get().getGuildRepository().addMember(guildUuid, player.getUniqueId(), GuildRole.MEMBER)
+                .thenCompose(unused -> Guilds.get().getGuildRepository().deleteInvite(guildUuid, player.getUniqueId()))
+                .whenComplete((unused, throwable) ->
+                {
+                    if (throwable != null)
+                    {
+                        send(player, messageComponent("guildStorageFailed"));
+                        return;
+                    }
+                    guild.addMember(player.getUniqueId());
+                    Guilds.get().getGuildHolder().indexMember(guildUuid, player.getUniqueId());
+                    guild.getMembers().stream().map(Member::getPlayer).filter(Objects::nonNull).forEach(memberPlayer ->
+                            send(memberPlayer, messageComponent("guildMemberJoined", player.getName())));
+                });
+    }
+
+    @Override
+    protected @NotNull List<String> suggestions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    {
+        if (!(sender instanceof Player player) || args.length != 1)
+        {
+            return ImmutableList.of();
+        }
+        try
+        {
+            return Guilds.get().getGuildRepository().invitesFor(player.getUniqueId()).join().stream()
+                    .map(invite -> Guilds.get().getGuildHolder().guildById(UUID.fromString(invite.getGuildUuid())).orElse(null))
+                    .filter(Objects::nonNull)
+                    .map(Guild::getName)
+                    .toList();
+        }
+        catch (RuntimeException ignored)
+        {
+            return ImmutableList.of();
+        }
+    }
+}

src/main/java/dev/plex/command/sub/CreateSubCommand.java

@@ -38,10 +38,15 @@ public class CreateSubCommand extends SimplePlexCommand
         {
             return messageComponent("alreadyInGuild");
         }
-        Guilds.get().getSqlGuildManager().insertGuild(Guild.create(player, StringUtils.join(args, " "))).whenComplete((guild, throwable) ->
+        Guilds.get().getGuildRepository().createGuild(player, StringUtils.join(args, " ")).whenComplete((guild, throwable) ->
         {
+            if (throwable != null)
+            {
+                send(player, messageComponent("guildStorageFailed"));
+                return;
+            }
             Guilds.get().getGuildHolder().addGuild(guild);
-            send(player, mmString("Created guild named " + guild.getName()));
+            send(player, messageComponent("guildCreated", guild.getName()));
         });
         return null;
     }

src/main/java/dev/plex/command/sub/DenySubCommand.java

@@ -0,0 +1,65 @@
+package dev.plex.command.sub;
+
+import dev.plex.Guilds;
+import dev.plex.command.SimplePlexCommand;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.storage.entity.GuildInviteEntity;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+public class DenySubCommand extends SimplePlexCommand
+{
+    public DenySubCommand()
+    {
+        super(command("deny")
+                .description("Denies a guild invite")
+                .usage("/guild <command> <guild>")
+                .permission("plex.guilds.deny")
+                .source(RequiredCommandSource.IN_GAME)
+                .build());
+    }
+
+    @Override
+    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+        assert player != null;
+        Guilds.get().getGuildRepository().invitesFor(player.getUniqueId()).whenComplete((invites, throwable) ->
+        {
+            if (throwable != null)
+            {
+                send(player, messageComponent("guildStorageFailed"));
+                return;
+            }
+            GuildInviteEntity invite = invites.stream()
+                    .filter(candidate -> Guilds.get().getGuildHolder().guildById(UUID.fromString(candidate.getGuildUuid()))
+                            .map(guild -> guild.getName().equalsIgnoreCase(String.join(" ", args)))
+                            .orElse(false))
+                    .findFirst()
+                    .orElse(null);
+            if (invite == null)
+            {
+                send(player, messageComponent("guildNotValidInvite"));
+                return;
+            }
+            Guilds.get().getGuildRepository().deleteInvite(UUID.fromString(invite.getGuildUuid()), player.getUniqueId()).whenComplete((unused, deleteThrowable) ->
+            {
+                if (deleteThrowable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                send(player, messageComponent("guildInviteDenied"));
+            });
+        });
+        return null;
+    }
+}

src/main/java/dev/plex/command/sub/DisbandSubCommand.java

@@ -0,0 +1,48 @@
+package dev.plex.command.sub;
+
+import dev.plex.Guilds;
+import dev.plex.command.SimplePlexCommand;
+import dev.plex.command.source.RequiredCommandSource;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class DisbandSubCommand extends SimplePlexCommand
+{
+    public DisbandSubCommand()
+    {
+        super(command("disband")
+                .description("Disbands your guild")
+                .usage("/guild <command>")
+                .permission("plex.guilds.disband")
+                .source(RequiredCommandSource.IN_GAME)
+                .build());
+    }
+
+    @Override
+    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] args)
+    {
+        assert player != null;
+        Guilds.get().getGuildHolder().guild(player.getUniqueId()).ifPresentOrElse(guild ->
+        {
+            if (!guild.isOwner(player.getUniqueId()))
+            {
+                send(player, messageComponent("guildNotOwner"));
+                return;
+            }
+            Guilds.get().getGuildRepository().deleteGuild(guild.getGuildUuid()).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                Guilds.get().getGuildHolder().removeGuild(guild.getGuildUuid());
+                send(player, messageComponent("guildDisbanded"));
+            });
+        }, () -> send(player, messageComponent("guildNotFound")));
+        return null;
+    }
+}

src/main/java/dev/plex/command/sub/InfoSubCommand.java

@@ -4,6 +4,7 @@ import dev.plex.Guilds;
 import dev.plex.api.player.PlexPlayerView;
 import dev.plex.command.SimplePlexCommand;
 import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.guild.Guild;
 import java.time.format.DateTimeFormatter;
 import java.util.Collections;
 import java.util.List;
@@ -31,29 +32,51 @@ public class InfoSubCommand extends SimplePlexCommand
     private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss a");
 
     @Override
-    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] strings)
+    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] args)
     {
         assert player != null;
         CompletableFuture.runAsync(() ->
         {
-            Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
+            Guild guild = resolveGuild(player, args);
+            if (guild == null)
+            {
+                send(player, messageComponent("guildNotFound"));
+                return;
+            }
             {
                 send(player, mmString("<gradient:yellow:gold>====<aqua>" + guild.getName() + "<gradient:yellow:gold>===="));
                 send(player, mmString(""));
-                send(player, mmString("<gold>Owner: <yellow>" + playerName(guild.getOwner().getUuid())));
-                List<String> members = guild.getMembers().stream().filter(member -> !member.getUuid().equals(guild.getOwner().getUuid())).map(member -> playerName(member.getUuid())).toList();
+                send(player, mmString("<gold>Owner: <yellow>" + playerName(guild.getOwnerUuid())));
+                List<String> members = guild.getMembers().stream().filter(member -> !member.getUuid().equals(guild.getOwnerUuid())).map(member -> playerName(member.getUuid())).toList();
                 send(player, mmString("<gold>Members (" + members.size() + "): " + StringUtils.join(members, ", ")));
-                send(player, mmString("<gold>Moderators (" + guild.getModerators().size() + "): " + StringUtils.join(guild.getModerators().stream().map(this::playerName).toList(), ", ")));
                 send(player, mmString("<gold>Prefix: " + (guild.getPrefix() == null ? "N/A" : guild.getPrefix())));
                 send(player, mmString("<gold>Created At: " + formatter.format(guild.getCreatedAt())));
-            }, () -> send(player, messageComponent("guildNotFound")));
+            }
         }, Guilds.get().api().scheduler().asyncExecutor());
         return null;
     }
 
+    private Guild resolveGuild(Player sender, String[] args)
+    {
+        if (args.length == 0)
+        {
+            return Guilds.get().getGuildHolder().guild(sender.getUniqueId()).orElse(null);
+        }
+        PlexPlayerView player = api().players().byName(args[0]).orElse(null);
+        if (player != null)
+        {
+            Guild guild = Guilds.get().getGuildHolder().guild(player.uuid()).orElse(null);
+            if (guild != null)
+            {
+                return guild;
+            }
+        }
+        return Guilds.get().getGuildHolder().guildByName(StringUtils.join(args, " ")).orElse(null);
+    }
+
     private String playerName(java.util.UUID uuid)
     {
-        return api().players().byUuid(uuid).map(PlexPlayerView::name).orElse("Unable to load cache...");
+        return api().players().player(uuid).map(PlexPlayerView::name).orElse(uuid.toString());
     }
 
     @Override

src/main/java/dev/plex/command/sub/InviteSubCommand.java

@@ -4,23 +4,15 @@ import com.google.common.collect.ImmutableList;
 import dev.plex.Guilds;
 import dev.plex.command.SimplePlexCommand;
 import dev.plex.command.source.RequiredCommandSource;
-import dev.plex.guild.Guild;
-import dev.plex.guild.GuildHolder;
-import dev.plex.guild.data.Member;
 import net.kyori.adventure.text.Component;
-import org.apache.commons.lang3.StringUtils;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-// TODO: 5/9/2022 5 minute timeout for invites
-// TODO: 5/9/2022 deny command maybe?
-// TODO: 5/9/2022 deny members from inviting themselves or existing members in the current guild
 
 public class InviteSubCommand extends SimplePlexCommand
 {
@@ -43,75 +35,34 @@ public class InviteSubCommand extends SimplePlexCommand
             return usage();
         }
         assert player != null;
-        if (args[0].equalsIgnoreCase("accept"))
-        {
-            if (!GuildHolder.PENDING_INVITES.containsKey(player.getUniqueId()))
-            {
-                return messageComponent("guildNoInvite");
-            }
-            String guildName = StringUtils.join(args, " ", 1, args.length);
-            GuildHolder.PENDING_INVITES.get(player.getUniqueId()).stream().filter(guild -> guild.getName().equalsIgnoreCase(guildName)).findFirst().ifPresentOrElse(guild ->
-            {
-                AtomicBoolean continueCheck = new AtomicBoolean(true);
-                Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresent(guild1 ->
-                {
-                    if (guild1.getGuildUuid().equals(guild.getGuildUuid()))
-                    {
-                        send(player, messageComponent("guildInThis"));
-                        continueCheck.set(false);
-                        return;
-                    }
-                    if (guild1.getOwner().getUuid().equals(player.getUniqueId()))
-                    {
-                        if (guild1.getMembers().size() - 1 > 0)
-                        {
-                            send(player, messageComponent("guildDisbandNeeded"));
-                            continueCheck.set(false);
-                            return;
-                        }
-                        else
-                        {
-                            Guilds.get().getSqlGuildManager().deleteGuild(guild1.getGuildUuid()).whenComplete((unused, throwable) ->
-                            {
-                                send(player, messageComponent("guildAutoDisbanded"));
-                            });
-                        }
-                    }
-                    guild1.getMembers().stream().map(Member::getPlayer).filter(Objects::nonNull).forEach(player1 ->
-                    {
-                        send(player1, messageComponent("guildMemberLeft", player.getName()));
-                    });
-                    guild1.getMembers().removeIf(member -> member.getUuid().equals(player.getUniqueId()));
-                });
-                if (!continueCheck.get())
-                {
-                    return;
-                }
-                GuildHolder.PENDING_INVITES.remove(player.getUniqueId());
-                guild.addMember(player.getUniqueId());
-                guild.getMembers().stream().map(Member::getPlayer).filter(Objects::nonNull).forEach(player1 ->
-                {
-                    send(player1, messageComponent("guildMemberJoined", player.getName()));
-                });
-            }, () -> send(player, messageComponent("guildNotValidInvite")));
-            return null;
-        }
         Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
         {
-            if (!guild.getOwner().getUuid().equals(player.getUniqueId()))
+            if (!guild.isOwner(player.getUniqueId()))
             {
                 send(player, messageComponent("guildNotOwner"));
                 return;
             }
             Player target = getNonNullPlayer(args[0]);
-            boolean invite = GuildHolder.sendInvite(target.getUniqueId(), guild);
-            if (!invite)
+            if (target.getUniqueId().equals(player.getUniqueId()))
             {
-                send(player, messageComponent("guildInviteExists"));
+                send(player, messageComponent("guildCannotInviteSelf"));
                 return;
             }
-            send(player, messageComponent("guildInviteSent", target.getName()));
-            send(target, messageComponent("guildInviteReceived", player.getName(), guild.getName()));
+            if (guild.getMember(target.getUniqueId()) != null || Guilds.get().getGuildHolder().guild(target.getUniqueId()).isPresent())
+            {
+                send(player, messageComponent("guildTargetAlreadyInGuild"));
+                return;
+            }
+            Guilds.get().getGuildRepository().createInvite(guild.getGuildUuid(), player.getUniqueId(), target.getUniqueId(), Instant.now().plus(5, ChronoUnit.MINUTES)).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                send(player, messageComponent("guildInviteSent", target.getName()));
+                send(target, messageComponent("guildInviteReceived", player.getName(), guild.getName()));
+            });
         }, () -> send(player, messageComponent("guildNotFound")));
         return null;
     }
@@ -119,23 +70,6 @@ public class InviteSubCommand extends SimplePlexCommand
     @Override
     protected @NotNull List<String> suggestions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
     {
-        if (!(sender instanceof Player player))
-        {
-            return ImmutableList.of();
-        }
-        if (args.length == 0)
-        {
-            return ImmutableList.of();
-        }
-        if (args[0].equalsIgnoreCase("accept") && args.length == 2)
-        {
-            if (!GuildHolder.PENDING_INVITES.containsKey(player.getUniqueId()))
-            {
-                return ImmutableList.of();
-            }
-            api().logging().debug("Completing pending guild invites");
-            return GuildHolder.PENDING_INVITES.get(player.getUniqueId()).stream().map(Guild::getName).collect(Collectors.toList());
-        }
-        return ImmutableList.of();
+        return args.length == 1 ? onlinePlayerNames() : ImmutableList.of();
     }
 }

src/main/java/dev/plex/command/sub/LeaveSubCommand.java

@@ -0,0 +1,68 @@
+package dev.plex.command.sub;
+
+import dev.plex.Guilds;
+import dev.plex.command.SimplePlexCommand;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.guild.data.Member;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class LeaveSubCommand extends SimplePlexCommand
+{
+    public LeaveSubCommand()
+    {
+        super(command("leave")
+                .description("Leaves your guild")
+                .usage("/guild <command>")
+                .permission("plex.guilds.leave")
+                .source(RequiredCommandSource.IN_GAME)
+                .build());
+    }
+
+    @Override
+    protected Component execute(@NotNull CommandSender commandSender, @Nullable Player player, @NotNull String[] args)
+    {
+        assert player != null;
+        Guilds.get().getGuildHolder().guild(player.getUniqueId()).ifPresentOrElse(guild ->
+        {
+            if (guild.isOwner(player.getUniqueId()))
+            {
+                if (guild.getMembers().size() > 1)
+                {
+                    send(player, messageComponent("guildOwnerLeaveBlocked"));
+                    return;
+                }
+                Guilds.get().getGuildRepository().deleteGuild(guild.getGuildUuid()).whenComplete((unused, throwable) ->
+                {
+                    if (throwable != null)
+                    {
+                        send(player, messageComponent("guildStorageFailed"));
+                        return;
+                    }
+                    Guilds.get().getGuildHolder().removeGuild(guild.getGuildUuid());
+                    send(player, messageComponent("guildAutoDisbanded"));
+                });
+                return;
+            }
+            Guilds.get().getGuildRepository().removeMember(guild.getGuildUuid(), player.getUniqueId()).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                guild.getMembers().removeIf(member -> member.getUuid().equals(player.getUniqueId()));
+                Guilds.get().getGuildHolder().unindexMember(player.getUniqueId());
+                guild.getMembers().stream().map(Member::getPlayer).filter(Objects::nonNull).forEach(memberPlayer ->
+                        send(memberPlayer, messageComponent("guildMemberLeft", player.getName())));
+                send(player, messageComponent("guildLeft"));
+            });
+        }, () -> send(player, messageComponent("guildNotFound")));
+        return null;
+    }
+}

src/main/java/dev/plex/command/sub/OwnerSubCommand.java

@@ -4,6 +4,7 @@ import dev.plex.Guilds;
 import dev.plex.api.player.PlexPlayerView;
 import dev.plex.command.SimplePlexCommand;
 import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.guild.data.GuildRole;
 import dev.plex.guild.data.Member;
 import java.util.Collections;
 import java.util.List;
@@ -20,7 +21,7 @@ public class OwnerSubCommand extends SimplePlexCommand
         super(command("owner")
                 .description("Sets the guild owner")
                 .usage("/guild <command> <player name>")
-                .aliases("setowner")
+                .aliases("setowner,promote")
                 .permission("plex.guilds.owner")
                 .source(RequiredCommandSource.IN_GAME)
                 .build());
@@ -36,7 +37,7 @@ public class OwnerSubCommand extends SimplePlexCommand
         assert player != null;
         Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
         {
-            if (!guild.getOwner().getUuid().equals(player.getUniqueId()))
+            if (!guild.isOwner(player.getUniqueId()))
             {
                 send(player, messageComponent("guildNotOwner"));
                 return;
@@ -54,10 +55,21 @@ public class OwnerSubCommand extends SimplePlexCommand
                 send(player, messageComponent("guildMemberNotFound"));
                 return;
             }
-            guild.setOwner(member);
-            guild.getMembers().remove(member);
-            guild.getMembers().add(memberSender);
-            send(player, messageComponent("guildOwnerSet", plexPlayer.name()));
+            Guilds.get().getGuildRepository().transferOwner(guild.getGuildUuid(), member.getUuid(), player.getUniqueId()).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                guild.setOwnerUuid(member.getUuid());
+                member.setRole(GuildRole.OWNER);
+                if (memberSender != null)
+                {
+                    memberSender.setRole(GuildRole.MEMBER);
+                }
+                send(player, messageComponent("guildOwnerSet", plexPlayer.name()));
+            });
         }, () -> send(player, messageComponent("guildNotFound")));
         return null;
     }

src/main/java/dev/plex/command/sub/PrefixSubCommand.java

@@ -36,19 +36,36 @@ public class PrefixSubCommand extends SimplePlexCommand
         assert player != null;
         Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
         {
-            if (!guild.getOwner().getUuid().equals(player.getUniqueId()))
+            if (!guild.isOwner(player.getUniqueId()))
             {
                 send(player, messageComponent("guildNotOwner"));
                 return;
             }
             if (args[0].equalsIgnoreCase("clear") || args[0].equalsIgnoreCase("off"))
             {
-                guild.setPrefix(null);
-                send(player, messageComponent("guildPrefixCleared"));
+                Guilds.get().getGuildRepository().updatePrefix(guild.getGuildUuid(), null).whenComplete((unused, throwable) ->
+                {
+                    if (throwable != null)
+                    {
+                        send(player, messageComponent("guildStorageFailed"));
+                        return;
+                    }
+                    guild.setPrefix(null);
+                    send(player, messageComponent("guildPrefixCleared"));
+                });
                 return;
             }
-            guild.setPrefix(StringUtils.join(args, " "));
-            send(player, messageComponent("guildPrefixSet", GuildUtil.miniMessageWithoutEvents(guild.getPrefix())));
+            String prefix = StringUtils.join(args, " ");
+            Guilds.get().getGuildRepository().updatePrefix(guild.getGuildUuid(), prefix).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                guild.setPrefix(prefix);
+                send(player, messageComponent("guildPrefixSet", GuildUtil.miniMessageWithoutEvents(guild.getPrefix())));
+            });
         }, () -> send(player, messageComponent("guildNotFound")));
         return null;
     }

src/main/java/dev/plex/command/sub/SetHomeSubCommand.java

@@ -31,7 +31,7 @@ public class SetHomeSubCommand extends SimplePlexCommand
         assert player != null;
         Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
         {
-            if (!guild.getOwner().getUuid().equals(player.getUniqueId()))
+            if (!guild.isOwner(player.getUniqueId()))
             {
                 send(player, messageComponent("guildNotOwner"));
                 return;
@@ -43,12 +43,29 @@ public class SetHomeSubCommand extends SimplePlexCommand
                     send(player, messageComponent("guildHomeNotFound"));
                     return;
                 }
-                guild.setHome(null);
-                send(player, messageComponent("guildHomeRemoved"));
+                Guilds.get().getGuildRepository().updateHome(guild.getGuildUuid(), null).whenComplete((unused, throwable) ->
+                {
+                    if (throwable != null)
+                    {
+                        send(player, messageComponent("guildStorageFailed"));
+                        return;
+                    }
+                    guild.setHome(null);
+                    send(player, messageComponent("guildHomeRemoved"));
+                });
                 return;
             }
-            guild.setHome(CustomLocation.fromLocation(player.getLocation()));
-            send(player, messageComponent("guildHomeSet"));
+            CustomLocation home = CustomLocation.fromLocation(player.getLocation());
+            Guilds.get().getGuildRepository().updateHome(guild.getGuildUuid(), home).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                guild.setHome(home);
+                send(player, messageComponent("guildHomeSet"));
+            });
         }, () -> send(player, messageComponent("guildNotFound")));
         return null;
     }

src/main/java/dev/plex/command/sub/SetWarpSubCommand.java

@@ -37,7 +37,7 @@ public class SetWarpSubCommand extends SimplePlexCommand
         assert player != null;
         Guilds.get().getGuildHolder().getGuild(player.getUniqueId()).ifPresentOrElse(guild ->
         {
-            if (!guild.getOwner().getUuid().equals(player.getUniqueId()))
+            if (!guild.isOwner(player.getUniqueId()))
             {
                 send(player, messageComponent("guildNotOwner"));
                 return;
@@ -48,18 +48,23 @@ public class SetWarpSubCommand extends SimplePlexCommand
                 send(player, mmString("<red>The max length of a warp name is 16 characters!"));
                 return;
             }
-            if (guild.getWarps().containsKey(warpName.toLowerCase()))
-            {
-                send(player, messageComponent("guildWarpExists", warpName));
-                return;
-            }
             if (!StringUtils.isAlphanumericSpace(warpName.toLowerCase(Locale.ROOT)))
             {
                 send(player, messageComponent("guildWarpAlphanumeric"));
                 return;
             }
-            guild.getWarps().put(warpName.toLowerCase(), CustomLocation.fromLocation(player.getLocation()));
-            send(player, messageComponent("guildWarpCreated", warpName));
+            CustomLocation location = CustomLocation.fromLocation(player.getLocation());
+            String localName = warpName.toLowerCase(Locale.ROOT);
+            Guilds.get().getGuildRepository().upsertWarp(guild.getGuildUuid(), localName, location).whenComplete((unused, throwable) ->
+            {
+                if (throwable != null)
+                {
+                    send(player, messageComponent("guildStorageFailed"));
+                    return;
+                }
+                guild.getWarps().put(localName, location);
+                send(player, messageComponent("guildWarpCreated", warpName));
+            });
         }, () -> send(player, messageComponent("guildNotFound")));
         return null;
     }