Add finished auction payment workflow

Author: ntbeastboy

client/src/main/java/com/auction/controller/AuctionListController.java

@@ -51,6 +51,7 @@ public class AuctionListController {
     @FXML private Button cancelBtn;
     @FXML private Button deleteBtn;
     @FXML private Button placeBidBtn;
+    @FXML private Button paySellerBtn;
     @FXML private Label statusLabel;
 
     private AppState appState;
@@ -87,6 +88,7 @@ private void setupTable() {
             });
             return row;
         });
+        itemTable.getSelectionModel().selectedItemProperty().addListener((obs, oldItem, newItem) -> updatePaySellerButton());
         colType.setCellValueFactory(c -> new SimpleStringProperty(typeName(c.getValue())));
         colStatus.setCellValueFactory(new PropertyValueFactory<>("status"));
         colPrice.setCellValueFactory(c ->
@@ -119,6 +121,7 @@ private void configureRoleButtons() {
         } else if (appState.currentUser instanceof Bidder) {
             show(addFundsBtn, withdrawBtn, placeBidBtn);
         }
+        updatePaySellerButton();
     }
 
     private void show(javafx.scene.Node... nodes) {
@@ -161,7 +164,7 @@ private void onAddFunds() {
     @FXML
     private void onWithdraw() {
         double committed = appState.itemRepository.findAll().stream()
-                .filter(i -> i.getStatus() == AuctionStatus.RUNNING
+                .filter(i -> (i.getStatus() == AuctionStatus.RUNNING || i.getStatus() == AuctionStatus.FINISHED)
                           && appState.currentUser.getId().equals(i.getCurrentWinnerId()))
                 .mapToDouble(Item::getCurrentPrice)
                 .sum();
@@ -236,6 +239,28 @@ private void onPlaceBid() {
         switchToBidding(selected);
     }
 
+    @FXML
+    private void onPaySeller() {
+        Item selected = itemTable.getSelectionModel().getSelectedItem();
+        if (selected == null) { showStatus("Select an item first.", true); return; }
+        if (selected.getStatus() != AuctionStatus.FINISHED) {
+            showStatus("Auction must be FINISHED before payment.", true);
+            return;
+        }
+        if (!appState.currentUser.getId().equals(selected.getCurrentWinnerId())) {
+            showStatus("Only the winning bidder can pay the seller.", true);
+            return;
+        }
+        try {
+            appState.auctionService.paySeller(selected.getId(), appState.currentUser);
+            refreshCurrentUser();
+            refreshTable();
+            showStatus("Seller paid.", false);
+        } catch (Exception e) {
+            showStatus(e.getMessage(), true);
+        }
+    }
+
     private void switchToBidding(Item item) {
         try {
             FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/bidding.fxml"));
@@ -261,6 +286,17 @@ private void refreshTable() {
         itemTable.setItems(FXCollections.observableArrayList(appState.itemRepository.findAll()));
         itemTable.refresh();
         refreshUserInfo();
+        updatePaySellerButton();
+    }
+
+    private void updatePaySellerButton() {
+        if (paySellerBtn == null || appState == null || appState.currentUser == null) return;
+        Item selected = itemTable.getSelectionModel().getSelectedItem();
+        boolean canPay = selected != null
+                && selected.getStatus() == AuctionStatus.FINISHED
+                && appState.currentUser.getId().equals(selected.getCurrentWinnerId());
+        paySellerBtn.setVisible(canPay);
+        paySellerBtn.setManaged(canPay);
     }
 
     private void registerRealtimeUpdates() {

client/src/main/java/com/auction/service/rest/RestAuctionService.java

@@ -42,6 +42,11 @@ public void cancelAuction(String itemId, User requestingUser) {
         post("/auction/" + itemId + "/cancel");
     }
 
+    @Override
+    public void paySeller(String itemId, User requestingUser) {
+        post("/auction/" + itemId + "/pay");
+    }
+
     @Override
     public void recoverScheduledAuctions() {
         // Server handles this on its own startup.

client/src/main/resources/fxml/auction-list.fxml

@@ -48,6 +48,7 @@
 
         <!-- Bidder / Seller -->
         <Button fx:id="placeBidBtn"    text="Place Bid"       onAction="#onPlaceBid"      styleClass="btn-primary"   managed="false" visible="false"/>
+        <Button fx:id="paySellerBtn"   text="Pay Seller"      onAction="#onPaySeller"     styleClass="btn-primary"   managed="false" visible="false"/>
     </HBox>
 
     <Label fx:id="statusLabel" styleClass="error-label"/>

server/src/main/java/com/auction/server/controller/AuctionController.java

@@ -50,6 +50,14 @@ public void handleCancelAuction(Context ctx) {
         ctx.json(Map.of("message", "Auction canceled."));
     }
 
+    public void handlePaySeller(Context ctx) {
+        String itemId = ctx.pathParam("id");
+        User user = getAuthenticatedUser(ctx);
+        auctionService.paySeller(itemId, user);
+        broadcastItemUpdated(itemId);
+        ctx.json(Map.of("message", "Seller paid."));
+    }
+
     private User getAuthenticatedUser(Context ctx) {
         String userId = ctx.attribute("userId");
         return userRepo.findById(userId)

server/src/main/java/com/auction/server/controller/UserController.java

@@ -144,7 +144,8 @@ private double committedAmount(String userId) {
         if (itemRepo == null) return 0.0;
         Map<String, Double> commitmentsByItem = new HashMap<>();
         for (Item item : itemRepo.findAll()) {
-            if (item.getStatus() == AuctionStatus.RUNNING && userId.equals(item.getCurrentWinnerId())) {
+            if ((item.getStatus() == AuctionStatus.RUNNING || item.getStatus() == AuctionStatus.FINISHED)
+                    && userId.equals(item.getCurrentWinnerId())) {
                 commitmentsByItem.merge(item.getId(), item.getCurrentPrice(), Math::max);
             }
         }

server/src/main/java/com/auction/server/network/AuctionServer.java

@@ -78,6 +78,7 @@ private void registerRoutes(UserController user, ItemController item,
         app.post("/api/auction/{id}/start", auction::handleStartAuction);
         app.post("/api/auction/{id}/end", auction::handleEndAuction);
         app.post("/api/auction/{id}/cancel", auction::handleCancelAuction);
+        app.post("/api/auction/{id}/pay", auction::handlePaySeller);
     }
 
     private ObjectMapper createObjectMapper() {

shared/src/main/java/com/auction/service/AuctionService.java

@@ -4,6 +4,7 @@
 import com.auction.exception.UnauthorizedActionException;
 import com.auction.model.Admin;
 import com.auction.model.AuctionStatus;
+import com.auction.model.BannableUser;
 import com.auction.model.Bidder;
 import com.auction.model.Item;
 import com.auction.model.Seller;
@@ -22,6 +23,9 @@
 
 public class AuctionService {
 
+    private static final Duration PAYMENT_WINDOW = Duration.ofHours(8);
+    private static final long NON_PAYMENT_BAN_SECONDS = Duration.ofDays(7).toSeconds();
+
     private final ItemRepository itemRepository;
     private final UserRepository userRepository;
     private final TransactionRunner txRunner;
@@ -53,21 +57,20 @@ private void runInTx(Runnable action) {
     }
 
     /**
-     * Recover from server restarts: any auction left in RUNNING status whose
-     * end-time has already passed is closed immediately; any still-active
-     * RUNNING auction has its close timer rescheduled.
+     * Recover from server restarts: RUNNING auctions are closed or rescheduled,
+     * and FINISHED auctions are expired or rescheduled for their payment window.
      */
     public void recoverScheduledAuctions() {
         LocalDateTime now = LocalDateTime.now();
         for (Item item : itemRepository.findAll()) {
-            if (item.getStatus() != AuctionStatus.RUNNING) continue;
-            if (item.getBidEndTime() == null || !now.isBefore(item.getBidEndTime())) {
-                // Already past the end time -> close now.
-                closeAuction(item.getId());
-            } else {
-                long delayMs = Duration.between(now, item.getBidEndTime()).toMillis();
-                String itemId = item.getId();
-                scheduler.schedule(() -> closeAuction(itemId), delayMs, TimeUnit.MILLISECONDS);
+            if (item.getStatus() == AuctionStatus.RUNNING) {
+                if (item.getBidEndTime() == null || !now.isBefore(item.getBidEndTime())) {
+                    closeAuction(item.getId());
+                } else {
+                    scheduleClose(item.getId(), Duration.between(now, item.getBidEndTime()));
+                }
+            } else if (item.getStatus() == AuctionStatus.FINISHED) {
+                scheduleOrExpireFinishedAuction(item);
             }
         }
     }
@@ -100,18 +103,16 @@ public void startAuction(String itemId, User requestingUser) {
             if (delayMs <= 0) {
                 closeAuction(itemId);
             } else {
-                scheduler.schedule(() -> closeAuction(itemId), delayMs, TimeUnit.MILLISECONDS);
+                scheduleClose(itemId, Duration.ofMillis(delayMs));
             }
         } finally {
             lock.unlock();
         }
     }
 
     /**
-     * Settle the auction: if there's a winner with sufficient funds, debit
-     * the winner, credit the seller, and mark FINISHED. If there are no
-     * bids or the winner can't afford the price, mark CANCELED. Either way
-     * the work commits atomically with the status flip.
+     * Close bidding. Auctions with a winner move to FINISHED and wait for the
+     * winner to pay the seller; auctions without a winner are canceled.
      */
     public void closeAuction(String itemId) {
         closeAuction(itemId, false);
@@ -129,9 +130,12 @@ private void closeAuction(String itemId, boolean force) {
             LocalDateTime now = LocalDateTime.now();
             if (!force && item.getBidEndTime() != null && now.isBefore(item.getBidEndTime())) {
                 long delayMs = Duration.between(now, item.getBidEndTime()).toMillis();
-                scheduler.schedule(() -> closeAuction(itemId), delayMs, TimeUnit.MILLISECONDS);
+                scheduleClose(itemId, Duration.ofMillis(delayMs));
                 return;
             }
+            if (force || item.getBidEndTime() == null) {
+                item.setBidEndTime(now);
+            }
 
             String winnerId = item.getCurrentWinnerId();
             if (winnerId == null) {
@@ -141,6 +145,41 @@ private void closeAuction(String itemId, boolean force) {
                 return;
             }
 
+            userRepository.findById(winnerId)
+                    .orElseThrow(() -> new ProductNotFoundException("Winner not found: " + winnerId));
+            userRepository.findById(item.getSellerId())
+                    .orElseThrow(() -> new ProductNotFoundException("Seller not found: " + item.getSellerId()));
+
+            item.setStatus(AuctionStatus.FINISHED);
+            runInTx(() -> itemRepository.update(item));
+            schedulePaymentExpiry(item.getId(), paymentDeadline(item));
+            if (statusChangeCallback != null) statusChangeCallback.run();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public void paySeller(String itemId, User requestingUser) {
+        ReentrantLock lock = ItemLockManager.getLock(itemId);
+        lock.lock();
+        try {
+            Item item = getItem(itemId);
+
+            if (item.getStatus() != AuctionStatus.FINISHED)
+                throw new IllegalStateException("Auction must be FINISHED before payment.");
+
+            String winnerId = item.getCurrentWinnerId();
+            if (winnerId == null)
+                throw new IllegalStateException("Cannot pay seller because this auction has no winner.");
+            if (!winnerId.equals(requestingUser.getId()))
+                throw new UnauthorizedActionException("Only the winning bidder can pay the seller.");
+
+            LocalDateTime deadline = paymentDeadline(item);
+            if (!LocalDateTime.now().isBefore(deadline)) {
+                expireFinishedAuction(itemId);
+                throw new IllegalStateException("Payment window has expired.");
+            }
+
             User winnerUser = userRepository.findById(winnerId)
                     .orElseThrow(() -> new ProductNotFoundException("Winner not found: " + winnerId));
             User sellerUser = userRepository.findById(item.getSellerId())
@@ -154,16 +193,9 @@ private void closeAuction(String itemId, boolean force) {
             else throw new IllegalStateException("Winner account is invalid for payment: " + winnerId);
 
             double price = item.getCurrentPrice();
-            if (winnerBalance < price) {
-                // Winner can't afford it (e.g. they withdrew before settlement).
-                // Cancel the auction so the seller doesn't get a phantom payout.
-                item.setStatus(AuctionStatus.CANCELED);
-                runInTx(() -> itemRepository.update(item));
-                if (statusChangeCallback != null) statusChangeCallback.run();
-                return;
-            }
+            if (winnerBalance < price)
+                throw new IllegalStateException("Insufficient balance to pay seller.");
 
-            item.setStatus(AuctionStatus.FINISHED);
             if (winnerUser instanceof Bidder b) b.deductFunds(price);
             else ((Seller) winnerUser).withdraw(price);
             seller.addFunds(price);
@@ -198,7 +230,7 @@ public void cancelAuction(String itemId, User requestingUser) {
             Item item = getItem(itemId);
             AuctionStatus current = item.getStatus();
 
-            if (current == AuctionStatus.FINISHED || current == AuctionStatus.PAID)
+            if (current == AuctionStatus.PAID)
                 throw new IllegalStateException("Cannot cancel a settled auction.");
             if (current == AuctionStatus.CANCELED)
                 throw new IllegalStateException("Auction is already CANCELED.");
@@ -218,4 +250,58 @@ private Item getItem(String itemId) {
         return itemRepository.findById(itemId)
                 .orElseThrow(() -> new ProductNotFoundException("Item not found: " + itemId));
     }
+
+    private void scheduleClose(String itemId, Duration delay) {
+        scheduler.schedule(() -> closeAuction(itemId), Math.max(0, delay.toMillis()), TimeUnit.MILLISECONDS);
+    }
+
+    private void scheduleOrExpireFinishedAuction(Item item) {
+        LocalDateTime deadline = paymentDeadline(item);
+        if (!LocalDateTime.now().isBefore(deadline)) {
+            expireFinishedAuction(item.getId());
+        } else {
+            schedulePaymentExpiry(item.getId(), deadline);
+        }
+    }
+
+    private void schedulePaymentExpiry(String itemId, LocalDateTime deadline) {
+        long delayMs = Math.max(0, Duration.between(LocalDateTime.now(), deadline).toMillis());
+        scheduler.schedule(() -> expireFinishedAuction(itemId), delayMs, TimeUnit.MILLISECONDS);
+    }
+
+    private LocalDateTime paymentDeadline(Item item) {
+        LocalDateTime finishedAt = item.getBidEndTime() != null ? item.getBidEndTime() : LocalDateTime.now();
+        return finishedAt.plus(PAYMENT_WINDOW);
+    }
+
+    private void expireFinishedAuction(String itemId) {
+        ReentrantLock lock = ItemLockManager.getLock(itemId);
+        lock.lock();
+        try {
+            Item item = getItem(itemId);
+            if (item.getStatus() != AuctionStatus.FINISHED) return;
+            if (LocalDateTime.now().isBefore(paymentDeadline(item))) {
+                schedulePaymentExpiry(itemId, paymentDeadline(item));
+                return;
+            }
+
+            User winnerUser = null;
+            if (item.getCurrentWinnerId() != null) {
+                winnerUser = userRepository.findById(item.getCurrentWinnerId()).orElse(null);
+                if (winnerUser instanceof BannableUser bu) {
+                    bu.banTemporary(NON_PAYMENT_BAN_SECONDS);
+                }
+            }
+
+            item.setStatus(AuctionStatus.CANCELED);
+            final User bannedWinner = winnerUser;
+            runInTx(() -> {
+                itemRepository.update(item);
+                if (bannedWinner != null) userRepository.save(bannedWinner);
+            });
+            if (statusChangeCallback != null) statusChangeCallback.run();
+        } finally {
+            lock.unlock();
+        }
+    }
 }