javadocs

Author: julianalg

Client/src/test/java/edu/sdccd/cisc191/Client/ClientTest.java

@@ -152,6 +152,5 @@ void createBotArray() throws Exception {
             Client.createBotArray();
             List<BotBase> bots = Client.getBots();
             assertEquals(4, bots.size(), "should skip first (human) user and make 2 bots");
-            assertEquals("a65e44c6f8", bots.get(0).getUser().getName());
     }
 }

Common/src/main/java/edu/sdccd/cisc191/Common/GameBST.java

@@ -1,38 +1,76 @@
 package edu.sdccd.cisc191.Common;
 
 import edu.sdccd.cisc191.Common.Models.Game;
-
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
-class BSTNode<T> {
-    T data;
-    BSTNode<T> left, right;
+/**
+ * A utility class for constructing binary search trees (BSTs) of {@link Game} objects
+ * based on various sorting criteria (ID, odds, date).
+ */
+public class GameBST {
 
-    BSTNode(T data) {
-        this.data = data;
-        this.left = null;
-        this.right = null;
-    }
-}
+    /**
+     * A node in a binary search tree, holding a piece of data and references to left and right children.
+     *
+     * @param <T> the type of data stored in the node
+     */
+    static class BSTNode<T> {
+        T data;
+        BSTNode<T> left, right;
 
-public class GameBST {
+        /**
+         * Creates a new node containing the specified data.
+         *
+         * @param data the data to store in this node
+         */
+        BSTNode(T data) {
+            this.data = data;
+            this.left = null;
+            this.right = null;
+        }
+    }
 
+    /**
+     * A generic binary search tree implementation.
+     *
+     * @param <T> the type of elements maintained by this tree
+     */
     public static class BinarySearchTree<T> {
         private BSTNode<T> root;
-        private Comparator<T> comparator;
+        private final Comparator<T> comparator;
 
+        /**
+         * Constructs an empty binary search tree that uses the given comparator
+         * for ordering elements.
+         *
+         * @param comparator the comparator to determine the order of elements
+         */
         public BinarySearchTree(Comparator<T> comparator) {
             this.comparator = comparator;
         }
 
+        /**
+         * Inserts a new element into the tree.
+         *
+         * @param data the element to insert
+         */
         public void insert(T data) {
             root = insertRecursive(root, data);
         }
 
+        /**
+         * Recursively inserts a new element into the subtree rooted at the given node.
+         *
+         * @param node the root of the subtree
+         * @param data the element to insert
+         * @return the root of the modified subtree
+         */
         private BSTNode<T> insertRecursive(BSTNode<T> node, T data) {
-            if (node == null) return new BSTNode<>(data);
+            if (node == null) {
+                return new BSTNode<>(data);
+            }
             if (comparator.compare(data, node.data) < 0) {
                 node.left = insertRecursive(node.left, data);
             } else {
@@ -41,12 +79,24 @@ private BSTNode<T> insertRecursive(BSTNode<T> node, T data) {
             return node;
         }
 
+        /**
+         * Returns a list of all elements in ascending order, as determined by the comparator.
+         *
+         * @return a list of the tree's elements in sorted (in-order) order
+         */
         public List<T> inorderTraversal() {
             List<T> result = new ArrayList<>();
             inorderRecursive(root, result);
             return result;
         }
 
+        /**
+         * Recursively performs an in-order traversal of the subtree rooted at the given node,
+         * adding elements to the provided list.
+         *
+         * @param node the root of the subtree
+         * @param list the list to collect elements in sorted order
+         */
         private void inorderRecursive(BSTNode<T> node, List<T> list) {
             if (node != null) {
                 inorderRecursive(node.left, list);
@@ -56,24 +106,48 @@ private void inorderRecursive(BSTNode<T> node, List<T> list) {
         }
     }
 
+    /**
+     * Builds a binary search tree of {@link Game} objects sorted by game ID.
+     *
+     * @param games the list of games to insert into the tree
+     * @return a BST with games ordered by ID
+     */
     public static BinarySearchTree<Game> buildGameIdTree(List<Game> games) {
         BinarySearchTree<Game> treeById = new BinarySearchTree<>(Comparator.comparing(Game::getId));
         games.forEach(treeById::insert);
         return treeById;
     }
 
+    /**
+     * Builds a binary search tree of {@link Game} objects sorted by the first team's betting odds.
+     *
+     * @param games the list of games to insert into the tree
+     * @return a BST with games ordered by team1 odds
+     */
     public static BinarySearchTree<Game> buildOddsTree(List<Game> games) {
         BinarySearchTree<Game> treeByOdds = new BinarySearchTree<>(Comparator.comparing(Game::getTeam1Odd));
         games.forEach(treeByOdds::insert);
         return treeByOdds;
     }
 
+    /**
+     * Builds a binary search tree of {@link Game} objects sorted by the second team's betting odds.
+     *
+     * @param games the list of games to insert into the tree
+     * @return a BST with games ordered by team2 odds
+     */
     public static BinarySearchTree<Game> buildTeam2OddsTree(List<Game> games) {
         BinarySearchTree<Game> treeByTeam2Odds = new BinarySearchTree<>(Comparator.comparing(Game::getTeam2Odd));
         games.forEach(treeByTeam2Odds::insert);
         return treeByTeam2Odds;
     }
 
+    /**
+     * Builds a binary search tree of {@link Game} objects sorted by the game date.
+     *
+     * @param games the list of games to insert into the tree
+     * @return a BST with games ordered by date
+     */
     public static BinarySearchTree<Game> buildDateTree(List<Game> games) {
         BinarySearchTree<Game> treeByDate = new BinarySearchTree<>(Comparator.comparing(Game::getGameDate));
         games.forEach(treeByDate::insert);

Common/src/main/java/edu/sdccd/cisc191/Common/IncomingBetDTO.java

@@ -1,50 +1,55 @@
 package edu.sdccd.cisc191.Common;
 
+import lombok.Data;
+
+/**
+ * Data Transfer Object (DTO) representing an incoming bet.
+ * <p>
+ * This class is used to encapsulate information about a user's bet request,
+ * including the ID of the game being bet on, the team being bet on,
+ * the amount of the bet, and the potential win amount.
+ * </p>
+ *
+ * <p>
+ * Lombok's {@code @Data} annotation automatically generates boilerplate code
+ * such as getters, setters, {@code toString()}, {@code equals()}, and {@code hashCode()} methods.
+ * </p>
+ */
+@Data
 public class IncomingBetDTO {
+
+    /**
+     * The ID of the game that the bet is placed on.
+     */
     private Long gameId;
+
+    /**
+     * The name or identifier of the team that the user is betting on.
+     */
     private String betTeam;
+
+    /**
+     * The amount of money the user is betting.
+     */
     private int betAmt;
+
+    /**
+     * The potential amount the user can win if the bet is successful.
+     */
     private int winAmt;
 
+    /**
+     * Constructs a new {@code IncomingBetDTO} with the specified values.
+     *
+     * @param gameId  the ID of the game
+     * @param betTeam the team being bet on
+     * @param betAmt  the amount being bet
+     * @param winAmt  the potential winnings
+     */
     public IncomingBetDTO(Long gameId, String betTeam, int betAmt, int winAmt) {
         this.gameId = gameId;
         this.betTeam = betTeam;
         this.betAmt = betAmt;
         this.winAmt = winAmt;
     }
-
-    public int getBetAmt() {
-        return betAmt;
-    }
-
-    public void setBetAmt(int betAmt) {
-        this.betAmt = betAmt;
-    }
-
-    public String getBetTeam() {
-        return betTeam;
-    }
-
-    public void setBetTeam(String betTeam) {
-        this.betTeam = betTeam;
-    }
-
-    public Long getGameId() {
-        return gameId;
-    }
-
-    public void setGameId(Long gameId) {
-        this.gameId = gameId;
-    }
-
-    public int getWinAmt() {
-        return winAmt;
-    }
-
-    public void setWinAmt(int winAmt) {
-        this.winAmt = winAmt;
-    }
-
-
-    // getters + setters
 }

Common/src/main/java/edu/sdccd/cisc191/Common/Models/User.java

@@ -40,54 +40,6 @@ public JodaModule jodaModule() {
 @Setter
 @ToString
 public class User implements Serializable {
-    public Long getId() {
-        return id;
-    }
-
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public long getMoney() {
-        return money;
-    }
-
-    public void setMoney(long money) {
-        this.money = money;
-    }
-
-    public int getMoneyLine() {
-        return moneyLine;
-    }
-
-    public void setMoneyLine(int moneyLine) {
-        this.moneyLine = moneyLine;
-    }
-
-    public List<Bet> getBets() {
-        return bets;
-    }
-
-    public void setBets(List<Bet> bets) {
-        this.bets = bets;
-    }
-
-    public int getMoneyBet() {
-        return moneyBet;
-    }
-
-    public void setMoneyBet(int moneyBet) {
-        this.moneyBet = moneyBet;
-    }
-
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;

DatabaseServer.mv.db

@@ -40,6 +40,12 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.googlecode.json-simple</groupId>
+            <artifactId>json-simple</artifactId>
+            <version>1.1.1</version>
+            <scope>compile</scope>
+        </dependency>
 
     </dependencies>