Merge pull request #29 from ShyamKrishna33/add-category-functionality

Add category functionality

src/main/java/budgetbuddy/BudgetBuddy.java

@@ -20,7 +20,7 @@ public static void main(String[] args) {
         String logo = "BUDGET BUDDY";
         System.out.println("Hello from\n" + logo);
         System.out.println("What can I do for you?");
-        Scanner in = new Scanner(System.in);
+        Scanner in = UserInterface.in;
 
         TransactionList transactions = null;
         try {

src/main/java/budgetbuddy/categories/Category.java

@@ -0,0 +1,38 @@
+package budgetbuddy.categories;
+
+public enum Category {
+    DINING(1, "Dining"),
+    GROCERIES(2, "Groceries"),
+    UTILITIES(3, "Utilities"),
+    TRANSPORTATION(4, "Transportation"),
+    HEALTHCARE(5, "Healthcare"),
+    ENTERTAINMENT(6, "Entertainment"),
+    RENT(7, "Rent"),
+    SALARY(8, "Salary"),
+    OTHERS(9, "Others");
+
+    private final int categoryNum;
+    private final String categoryName;
+
+    Category(int categoryNum, String categoryName) {
+        this.categoryNum = categoryNum;
+        this.categoryName = categoryName;
+    }
+
+    public static Category fromNumber(int number) {
+        for (Category category : Category.values()) {
+            if (category.categoryNum == number) {
+                return category;
+            }
+        }
+        return null;
+    }
+
+    public String getCategoryName() {
+        return categoryName;
+    }
+
+    public int getCategoryNum() {
+        return categoryNum;
+    }
+}

src/main/java/budgetbuddy/parser/Parser.java

@@ -1,6 +1,7 @@
 package budgetbuddy.parser;
 
 import budgetbuddy.account.Account;
+import budgetbuddy.categories.Category;
 import budgetbuddy.exceptions.EmptyArgumentException;
 import budgetbuddy.exceptions.InvalidTransactionTypeException;
 import budgetbuddy.transaction.TransactionList;
@@ -48,12 +49,20 @@ public Transaction parseTransaction(String input, Account account)
         }
         assert amount != null;
         assert type != null;
-        if(description.trim().isEmpty() || category.trim().isEmpty() || type.trim().isEmpty()){
+        if(description.trim().isEmpty() || type.trim().isEmpty()){
             throw new EmptyArgumentException("data for the arguments ");
         } else if (type.equalsIgnoreCase("income")) {
-            return new Income(description, Double.parseDouble(amount), category, date, account);
+            Income income = new Income(description, Double.parseDouble(amount), date, account);
+            if (category != null){
+                income.setCategory(Category.fromNumber(Integer.parseInt(category)));
+            }
+            return income;
         } else if (type.equalsIgnoreCase("expense")) {
-            return new Expense(description, Double.parseDouble(amount), category, date, account);
+            Expense expense = new Expense(description, Double.parseDouble(amount), date, account);
+            if (category != null){
+                expense.setCategory(Category.fromNumber(Integer.parseInt(category)));
+            }
+            return expense;
         } else {
             throw new InvalidTransactionTypeException(type);
         }

src/main/java/budgetbuddy/storage/DataStorage.java

@@ -1,6 +1,7 @@
 package budgetbuddy.storage;
 
 import budgetbuddy.account.Account;
+import budgetbuddy.categories.Category;
 import budgetbuddy.transaction.type.Expense;
 import budgetbuddy.transaction.type.Income;
 import budgetbuddy.transaction.type.Transaction;
@@ -46,23 +47,28 @@ private static void writeToFile(String stringToWrite) throws IOException {
     private static String getStringToWrite(Transaction t) {
         LocalDate date = t.getDate();
         String stringDate = date.format(DateTimeFormatter.ofPattern("dd-MM-yyyy"));
-        return t.getDescription() + " ," + t.getCategory() + " ," + t.getTransactionType() + " ," + stringDate
-                + " ," + t.getAmount() + "\n";
+        return t.getDescription() + " ," + t.getCategory().getCategoryNum() + " ,"
+                + t.getTransactionType() + " ," + stringDate + " ," + t.getAmount() + "\n";
     }
 
     private Transaction processData(String s, Account account) {
         String[] transactionInfo = s.split(" ,");
+        int categoryNum = Integer.parseInt(transactionInfo[1]);
 
         assert transactionInfo.length == 5 : "Invalid transaction information format";
         assert transactionInfo[2].equals("Income") || transactionInfo[2].equals("Expense") : "Invalid transaction type";
 
         switch (transactionInfo[2]) {
         case "Income":
-            return new Income(transactionInfo[0], Double.parseDouble(transactionInfo[4]),
-                    transactionInfo[1], transactionInfo[3], account);
+            Income incomeObj = new Income(transactionInfo[0], Double.parseDouble(transactionInfo[4]),
+                    transactionInfo[3], account);
+            incomeObj.setCategory(Category.fromNumber(categoryNum));
+            return incomeObj;
         case "Expense":
-            return new Expense(transactionInfo[0], -Double.parseDouble(transactionInfo[4]),
-                    transactionInfo[1], transactionInfo[3], account);
+            Expense expenseObj = new Expense(transactionInfo[0], -Double.parseDouble(transactionInfo[4]),
+                    transactionInfo[3], account);
+            expenseObj.setCategory(Category.fromNumber(categoryNum));
+            return expenseObj;
         default:
             return null;
         }

src/main/java/budgetbuddy/transaction/TransactionList.java

@@ -1,6 +1,7 @@
 package budgetbuddy.transaction;
 
 import budgetbuddy.account.Account;
+import budgetbuddy.categories.Category;
 import budgetbuddy.exceptions.EmptyArgumentException;
 import budgetbuddy.exceptions.InvalidAddTransactionSyntax;
 import budgetbuddy.exceptions.InvalidIndexException;
@@ -87,7 +88,7 @@ void addTransaction(Transaction t) {
     public void processTransaction(String input, Account account)
             throws InvalidTransactionTypeException, InvalidAddTransactionSyntax, EmptyArgumentException {
         // Check for syntax for add transaction
-        String[] arguments = {"/t/", "/n/", "/$/", "/d/", "/c/"};
+        String[] arguments = {"/t/", "/n/", "/$/", "/d/"};
         for (String argument : arguments) {
             if (!input.contains(argument)) {
                 throw new InvalidAddTransactionSyntax("Invalid add syntax.");
@@ -96,6 +97,11 @@ public void processTransaction(String input, Account account)
 
         Transaction t = parser.parseTransaction(input, account);
         assert t != null : "Parsed transaction is null";
+        if (t.getCategory() == null) {
+            UserInterface.listCategories();
+            int category = UserInterface.getCategoryNum();
+            t.setCategory(Category.fromNumber(category));
+        }
         addTransaction(t);
         assert transactions.get(transactions.size() - 1) != null : "Added transaction is null after adding to the list";
         String fetchData = String.valueOf(transactions.get(transactions.size() - 1));

src/main/java/budgetbuddy/transaction/type/Expense.java

@@ -5,11 +5,10 @@
 public class Expense extends Transaction {
     private static final String TRANSACTION_TYPE = "Expense";
 
-    public Expense(String description, double amount, String category, String date, Account account) {
-        super(description, -amount, category, date);
+    public Expense(String description, double amount, String date, Account account) {
+        super(description, -amount, date);
         assert this.getAmount() < 0: "Expense amount must be positive";
         assert description != null && !description.isEmpty() : "Description cannot be null or empty";
-        assert category != null && !category.isEmpty() : "Category cannot be null or empty";
         assert date != null : "Date cannot be null";
         assert account != null : "Account cannot be null";
 

src/main/java/budgetbuddy/transaction/type/Income.java

@@ -5,11 +5,10 @@
 public class Income extends Transaction {
     private static final String TRANSACTION_TYPE = "Income";
 
-    public Income(String description, double amount, String category, String date, Account account) {
-        super(description, amount, category, date);
+    public Income(String description, double amount, String date, Account account) {
+        super(description, amount, date);
         assert this.getAmount() > 0: "Income amount must be positive";
         assert description != null && !description.isEmpty() : "Description cannot be null or empty";
-        assert category != null && !category.isEmpty() : "Category cannot be null or empty";
         assert date != null : "Date cannot be null";
         assert account != null : "Account cannot be null";
 

src/main/java/budgetbuddy/transaction/type/Transaction.java

@@ -1,18 +1,19 @@
 package budgetbuddy.transaction.type;
 
+import budgetbuddy.categories.Category;
+
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 
 public abstract class Transaction {
     private String description;
     private double amount;
-    private String category;
+    private Category category;
     private LocalDate date;
 
-    public Transaction(String description, double amount, String category,String date) {
+    public Transaction(String description, double amount,String date) {
         this.description = description;
         this.amount = amount;
-        this.category = category;
         this.date = parseDate(date);
     }
 
@@ -32,7 +33,7 @@ private LocalDate parseDate(String by) {
         return LocalDate.parse(by, DateTimeFormatter.ofPattern("dd-MM-yyyy"));
     }
 
-    public String getCategory() {
+    public Category getCategory() {
         return category;
     }
 
@@ -44,6 +45,10 @@ public String toString() {
                 " Description: " + getDescription() + " | " +
                 " Date: " + getDate() + " | " +
                 " Amount: " + getAmount() + " | " +
-                " Category: " + getCategory()) ;
+                " Category: " + getCategory().getCategoryName()) ;
+    }
+
+    public void setCategory(Category category) {
+        this.category = category;
     }
 }

src/main/java/budgetbuddy/ui/UserInterface.java

@@ -1,9 +1,11 @@
 package budgetbuddy.ui;
 
+import budgetbuddy.categories.Category;
 import budgetbuddy.transaction.type.Transaction;
 
 import java.time.LocalDate;
 import java.util.ArrayList;
+import java.util.Scanner;
 
 public class UserInterface {
 
@@ -16,6 +18,22 @@ public class UserInterface {
 
     private static final String TAB_SPACE = "    ";
 
+    public static Scanner in = new Scanner(System.in);
+
+    public static void listCategories(){
+        System.out.println(LINE);
+        System.out.println(TAB_SPACE + "Here are the available categories:");
+        for(Category category : Category.values()) {
+            System.out.println(TAB_SPACE + TAB_SPACE + category.getCategoryName() + ": " + category.getCategoryNum());
+        }
+        System.out.println(LINE);
+    }
+
+    public static int getCategoryNum(){
+        System.out.println("In which category do you want to list this transaction? [Enter number between 1 and 9]");
+        String input = in.nextLine();
+        return Integer.parseInt(input);
+    }
 
     public static void printDeleteMessage(String transaction, double balance){
         String[] parts = transaction.split("\\|");
@@ -98,7 +116,7 @@ public static void printAllTransactions(ArrayList<Transaction> transactions, dou
             String description = transaction.getDescription();
             LocalDate date = transaction.getDate();
             double amount = transaction.getAmount();
-            String category = transaction.getCategory();
+            String category = transaction.getCategory().getCategoryName();
 
             System.out.printf(TAB_SPACE+TAB_SPACE + "%-5d %-10s %-50.45s %-20s %-15.2f  %-15s%n", i + 1, type,
                     description, date, amount, category);

src/test/java/budgetbuddy/parser/ParserTest.java

@@ -17,10 +17,10 @@ public void testParseTransaction() throws InvalidTransactionTypeException, Empty
         Parser parser = new Parser();
         Account account = new Account();
         Transaction transaction = parser.parseTransaction("add /t/Income /n/Shopping /$/50 /d/14-03-2024 " +
-                "/c/Personal", account);
+                "/c/1", account);
         assertEquals("Shopping", transaction.getDescription());
         assertEquals(50.0f, transaction.getAmount(), 0.001);
         assertEquals(LocalDate.parse("14-03-2024", DateTimeFormatter.ofPattern("dd-MM-yyyy")), transaction.getDate());
-        assertEquals("Personal", transaction.getCategory());
+        assertEquals("Dining", transaction.getCategory().getCategoryName());
     }
 }

src/test/java/budgetbuddy/transaction/TransactionListTest.java

@@ -1,6 +1,7 @@
 package budgetbuddy.transaction;
 
 import budgetbuddy.account.Account;
+import budgetbuddy.categories.Category;
 import budgetbuddy.exceptions.EmptyArgumentException;
 import budgetbuddy.exceptions.InvalidAddTransactionSyntax;
 import budgetbuddy.exceptions.InvalidIndexException;
@@ -34,45 +35,47 @@ public void getTransactions_initiallyEmpty() {
     @Test
     public void processTransaction_addsTransaction()
             throws InvalidTransactionTypeException, InvalidAddTransactionSyntax, EmptyArgumentException {
-        Transaction testTransaction = new Income("Test", 200,"Personal", "14-03-2024",
+        Transaction testTransaction = new Income("Test", 200, "14-03-2024",
                 account);
-        transactionList.processTransaction("add /t/Income /n/Test /$/200 /d/14-03-2024 /c/Personal", account);
+        testTransaction.setCategory(Category.fromNumber(1));
+        transactionList.processTransaction("add /t/Income /n/Test /$/200 /d/14-03-2024 /c/1", account);
 
         assertEquals(1, transactionList.getTransactions().size());
         assertEquals(testTransaction.getDescription(), transactionList.getTransactions().get(0).getDescription());
         assertEquals(testTransaction.getAmount(), transactionList.getTransactions().get(0).getAmount());
-        assertEquals(testTransaction.getCategory(), transactionList.getTransactions().get(0).getCategory());
+        assertEquals(testTransaction.getCategory().getCategoryName(),
+                transactionList.getTransactions().get(0).getCategory().getCategoryName());
         assertEquals(testTransaction.getDate(), transactionList.getTransactions().get(0).getDate());
     }
-
     @Test
+
     public void processTransaction_withInvalidAddSyntax_throwsInvalidAddTransactionSyntax() {
 
         assertThrows(InvalidAddTransactionSyntax.class, () -> transactionList.processTransaction(
-                "add Expense /n/Shopping /$/50 /d/14-03-2024 /c/Personal", account));
-        assertThrows(InvalidAddTransactionSyntax.class, () -> transactionList.processTransaction(
-                "add /t/Expense Shopping /$/50 /d/14-03-2024 /c/Personal", account));
+                "add Expense /n/Shopping /$/50 /d/14-03-2024 /c/2", account));
         assertThrows(InvalidAddTransactionSyntax.class, () -> transactionList.processTransaction(
-                "add /t/Expense /n/Shopping 50 /d/14-03-2024 /c/Personal", account));
+                "add /t/Expense Shopping /$/50 /d/14-03-2024 /c/2", account));
         assertThrows(InvalidAddTransactionSyntax.class, () -> transactionList.processTransaction(
-                "add /t/Expense /n/Shopping /$/50 14-03-2024 /c/Personal", account));
+                "add /t/Expense /n/Shopping 50 /d/14-03-2024 /c/2", account));
         assertThrows(InvalidAddTransactionSyntax.class, () -> transactionList.processTransaction(
-                "add /t/Expense /n/Shopping /$/50 /d/14-03-2024 Personal", account));
+                "add /t/Expense /n/Shopping /$/50 14-03-2024 /c/2", account));
     }
 
     @Test
     public void processTransaction_withInvalidTransactionType_throwsTransactionTypeException() {
 
         assertThrows(InvalidTransactionTypeException.class, () -> transactionList.processTransaction(
-                "add /t/Donation /n/Test /$/200 /d/14-03-2024 /c/Personal", account));
+                "add /t/Donation /n/Test /$/200 /d/14-03-2024 /c/2", account));
     }
 
     @Test
     public void removeTransaction_removesCorrectTransaction() throws EmptyArgumentException, InvalidIndexException {
-        Transaction testTransaction1 = new Income("Test1", 100, "Category1",
+        Transaction testTransaction1 = new Income("Test1", 100,
                 "14-03-2024", account);
-        Transaction testTransaction2 = new Income("Test2", 200, "Category2",
+        testTransaction1.setCategory(Category.fromNumber(1));
+        Transaction testTransaction2 = new Income("Test2", 200,
                 "16-03-2024", account);
+        testTransaction1.setCategory(Category.fromNumber(2));
         transactionList.addTransaction(testTransaction1);
         transactionList.addTransaction(testTransaction2);
 
@@ -84,7 +87,7 @@ public void removeTransaction_removesCorrectTransaction() throws EmptyArgumentEx
 
     @Test
     public void removeTransaction_withInvalidIndex_throwsIndexOutOfBoundsException() {
-        Transaction testTransaction = new Income("Test", 200, "Personal",
+        Transaction testTransaction = new Income("Test", 200,
                 "14-03-2024", account);
         transactionList.addTransaction(testTransaction);
 
@@ -94,7 +97,7 @@ public void removeTransaction_withInvalidIndex_throwsIndexOutOfBoundsException()
 
     @Test
     public void removeTransaction_withMissingIndex_throwsEmptyArgumentException() {
-        Transaction testTransaction = new Income("Test", 100, "Personal",
+        Transaction testTransaction = new Income("Test", 100,
                 "14-03-2024", account);
         transactionList.addTransaction(testTransaction);
 
@@ -104,7 +107,7 @@ public void removeTransaction_withMissingIndex_throwsEmptyArgumentException() {
 
     @Test
     public void removeTransaction_withInvalidIndex_throwsNumberFormatException() {
-        Transaction testTransaction = new Income("Test", 100, "Personal",
+        Transaction testTransaction = new Income("Test", 100,
                 "14-03-2024", account);
         transactionList.addTransaction(testTransaction);