Add concurrency lock to prevent duplicate payments in PayCommand

- Introduced `payLock` to ensure one payment per sender at a time.
- Updated `pay` function to handle concurrency gracefully with appropriate feedback to users.
- Cleaned up formatting and added error handling improvements.

Author: twisti-dev

surf-transaction-paper/src/main/kotlin/dev/slne/surf/transaction/paper/commands/pay/PayCommand.kt

@@ -20,8 +20,10 @@ import dev.slne.surf.transaction.paper.commands.CommandPermission
 import dev.slne.surf.transaction.paper.redis.events.pay.PaymentReceivedEvent
 import org.bukkit.entity.Player
 import java.util.*
+import java.util.concurrent.ConcurrentHashMap
 
 private val log = logger()
+private val payLock = ConcurrentHashMap.newKeySet<UUID>()
 
 fun payCommand() = commandTree("pay") {
     withPermission(CommandPermission.PAY)
@@ -40,7 +42,6 @@ fun payCommand() = commandTree("pay") {
     }
 }
 
-
 private suspend fun pay(
     sender: Player,
     receiverUuid: UUID,
@@ -50,33 +51,46 @@ private suspend fun pay(
         throw CommandAPI.failWithString("Du kannst dir kein Geld selbst überweisen!")
     }
 
-    val currency = Currency.default()
-    val result = sender.transactionUser().transfer(
-        amount = amount.toBigDecimal(),
-        currency = currency,
-        receiver = TransactionUser.byUuid(receiverUuid).getDefaultAccount()
-    )
-
-    when (result) {
-        is TransactionResult.Success, is TransactionResult.TransferSuccess -> handleSuccess(
-            sender,
-            receiverUuid,
-            amount,
-            currency
-        )
+    if (!payLock.add(sender.uniqueId)) {
+        throw CommandAPI.failWithString("Du führst bereits eine Überweisung durch. Bitte warte einen Moment...")
+    }
 
-        TransactionResult.ReceiverInsufficientFunds -> handleReceiverInsufficientFunds(
-            sender,
-            receiverUuid,
-            currency
-        )
+    sender.sendText {
+        appendPrefix()
+        info("Überweisung wird ausgeführt...")
+    }
 
-        TransactionResult.SenderInsufficientFunds -> handleSenderInsufficientFunds(
-            sender,
-            currency
+    try {
+        val currency = Currency.default()
+        val result = sender.transactionUser().transfer(
+            amount = amount.toBigDecimal(),
+            currency = currency,
+            receiver = TransactionUser.byUuid(receiverUuid).getDefaultAccount()
         )
 
-        is TransactionResult.DatabaseError -> handleError(sender, result)
+        when (result) {
+            is TransactionResult.Success, is TransactionResult.TransferSuccess -> handleSuccess(
+                sender,
+                receiverUuid,
+                amount,
+                currency
+            )
+
+            TransactionResult.ReceiverInsufficientFunds -> handleReceiverInsufficientFunds(
+                sender,
+                receiverUuid,
+                currency
+            )
+
+            TransactionResult.SenderInsufficientFunds -> handleSenderInsufficientFunds(
+                sender,
+                currency
+            )
+
+            is TransactionResult.DatabaseError -> handleError(sender, result)
+        }
+    } finally {
+        payLock.remove(sender.uniqueId)
     }
 }