Expense Tracker- Developer Guide

Go to File > Settings…​ (Windows/Linux), or IntelliJ IDEA > Preferences…​ (macOS)

Select Editor > Code Style > Java

Click on the Imports tab to set the order

Configure the site-wide documentation settings in build.gradle, such as the site-name, to suit your own project.

Replace the URL in the attribute repoURL in DeveloperGuide.adoc and UserGuide.adoc with the URL of your fork.

The user launches the application and the directory path in the UserPref points at the data folder

The method StorageManager#readAllExpenses(Path) is called by the MainApp and the method loads all the xml data files in the data folder and returns the loaded data as a Map<Username, EncryptedExpensetracker> with the Username of the user data as the key and the user data as an EncryptedExpenseTracker as the value to the MainApp class.

A Model instance will then be initialized using the previously mentioned Map of user data.

The user executes the command signup john to create a user with the Username john

The signup command calls Model#addUser(Username) which adds the user john to Model. The operation is successful as john does not break any of the Username constraints and does not already exist in the Model.

The user then executes the command login u/john to log in to his user account

The login command calls the LoginCredentials(Username, String) constructor with a null String password as a password was not provided.

The login command then calls Model#loadUserData(LoginCredentials) with the LoginCredentials instance created in the previous step. The method is executed successfully as the user john has no password set.

john’s data that is stored as EncryptedExpenseTracker is decrypted using the EncryptedExpenseTracker#decryptTracker(String) using an encryption key generated from john’s password (In this case an empty String is used as the password since john’s account has no password).

The selected data in Model is switched to john’s and an UserLoggedInEvent is raised for UI to show john’s Expense Tracker data Below is the UML sequence diagram that shows how SignUpCommand works.

The user is already logged in to the account john with an existing password password1 and executes the command setPassword o/password1 n/password2 to change his password to password2

The setPassword command calls the Model#setPassword(Password) method since the given old password matches his existing password and password2 does not violate any password constraints

The Model#setPassword(Password) method changes john’s account password to password2

john’s expense data gets encrypted using a new encryption key generated from the String password2. This also applies in future whenever it is saved to the data file.

User enters command stats command e.g. stats n/7 p/d m/t. The command is received by ExpenseTrackerParser, which calls creates StatsCommand and calls StatsCommandParser#parse() to create StatsCommand.

If no parameters are provided by the user, StatsCommand#StatsCommand() is called to create StatsCommand with the default parameters of periodAmount as 7, period as d and mode as t. Otherwise, StatsCommand#StatsCommand(periodAmount, period, mode) is called to create StatsCommand with the specified parameters.

StatsCommand checks if the parameters are valid. If any parameter is invalid, an exception will be raised and a message will be displayed to the user. Otherwise, the parameters are stored in instance variables and StatsCommand is returned to LogicManager.

LogicManager then calls StatsCommand#execute(), which updates expensePredicate, statsMode, statsPeriod and periodAmount in ModelManager, which are variables in ModelManager relevant for statistics. StatsCommand#execute() also posts ShowStatsRequestEvent and SwapLeftPanelEvent events to EventsCenter.

The ShowStatsRequestEvent event is handled by MainWindow#handleShowStatsEvent(), which calls 'StatisticsPanel#setData()' and passes the data as parameters by calling Logic#getExpenseStats(), Logic#getStatsPeriod(), Logic#getStatsMode() and Logic#getPeriodAmount().

Logic#getExpenseStats() gets the filtered expense list by calling Model#getExpenseStats(), which returns an unmodifiable ObservableList, only containing only expenses in the last 7 days, as per ModelManager#expensePredicate, and sorted by date.

Logic#getExpenseStats() then organises the data into a LinkedHashMap<String, Double>, where the key value pair represents the data series of the chart. If StatsMode is set to TIME, the key and value pair represents date and cost. If StatsMode is set to CATEGORY, the key value pair represents category and cost. Regardless of mode, the values are cumulative and is implemented using the algorithm in the following code snippet, using the example of category mode:

LinkedHashMap<String, Double> stats = new LinkedHashMap<>();
for (Expense e : expenseList) {
    String category;
    category = e.getCategory().categoryName;

    if (stats.containsKey(category)) {
        stats.put(
                category,
                stats.get(category) + e.getCost().getCostValue()
        );
    } else {
        stats.put(category, e.getCost().getCostValue());
    }
}

Logic#getStatsPeriod(), Logic#getStatsMode() and Logic#getPeriodAmount() gets their respective data by calling the method of the same name in Model.

Once the parameters are passed into StatisticsPanel#setData(), StackPane#getChildren()#clear() is called to clear any display elements in StackPane. JavaFX’s BarChart and PieChart are used to render the charts. There are three scenarios which could happen:

User enters command find n/Have Lunch f/Food d/01-01-2018:03-01-2018. The command is received by ExpenseTrackerParser, which then creates a FindCommandParser Object and calls FindCommandParser#parse() method.

FindCommandParser#parse() method calls ArgumentTokenizer#tokenize() to tokenize the input String into keywords and store them in an ArgumentMultimap Object.

FindCommandParser#parse() method then calls ParserUtil#ensureKeywordsAreValid() method. If any of the keywords doesn’t conform to the correct format, ParseException will be thrown. If no exception is thrown, a ExpenseContainsKeywordsPredicate Object is created. It implements Predicate<Expense> interface and is used to filter out all the expenses which matches the keywords entered by the user.

A FindCommand Object with the ExpenseContainsKeywordsPredicate Object as parameter is created and returned to LogicManager.

LogicManager then calls FindCommand#execute(),which calls Model#updateFilteredExpenseList() method to update the predicate of FilterList<Expense>. FilterList now contains new set of expenses which filtered by the new predicate.

Then the expense list panel will show a new set of expenses according to the keywords. A CommandResult is then created and returned to LogicManager.

User enters command massedit c/school -> c/work d/01-01-2018. The command is received by ExpenseTrackerParser, which then creates a MassEditCommandParser Object and calls MassEditCommandParser#parse() method.

MassEditCommandParser#parse() method calls ArgumentTokenizer#tokenize() to tokenize the input String into keywords and store them in two ArgumentMultimap Objects.

MassEditCommandParser#parse() method then create a ExpenseContainsKeywordsPredicate Object. Then it calls EditExpenseDescriptor#createEditExpenseDescriptor() method to create an EditExpenseDescriptor Object which stores the fields of expenses which are going to be edited.

A MassEditCommand Object with the ExpenseContainsKeywordsPredicate and EditExpenseDescriptor Object as parameters is created and returned to LogicManager.

LogicManager then calls MassEditCommand#execute(),which calls Model#updateFilteredExpenseList() method to update the predicate of FilterList<Expense>. Model#getFilteredExpenseList() is called to return the FilterList<Expense>.

All the Expense in the FilterList<Expense> are then added to a new list. A loop starts and for each Expense in the list, EditExpenseDescriptor#createEditedExpense() is called to create an edited Expense object. Then Model#updateExpense is called to replace the original Expense with edited Expense.

When loop ends, Model#updateFilteredExpenseList() is called to show the edit Expense to the user. A CommandResult is then created and returned to LogicManager.

The user launches the application and signs up for a new account. The MainWindow creates a new BudgetPanel, which elements are initialized as follows:

The user executes an add command. As the add command modifies budget and expenses, AddCommand#execute() will post a UpdateBudgetPanelEvent event to the EventsCenter.

The UpdateBudgetPanelEvent event is handled by MainWindow#handleBudgetPanelEvent(), which calls BudgetPanel#update().

BudgetPanel#update() calls BudgetPanel#animateBudgetPanel(), which creates a new Timeline object.

Two KeyFrame objects are added to Timeline, creating the animation BudgetPanel#budgetBar that transits the BudgetPanel#budgetBar#progress to the updated number.

A call to 'BudgetPanel#addTextAnimationKeyFrames()` is made to add the KeyFrame objects required to create the incrementing animation for BudgetPanel#expenseDisplay and BudgetPanel#budgetCapDisplay. In each KeyFrame, BudgetPanel#updateExpenseDisplay() and BudgetPanel#updateBudgetCapDisplay() is called to increment the BudgetPanel#expenseDisplay and BudgetPanel#budgetCapDisplay respectively.

A call is also made to BudgetPanel#alterTextSize() in each KeyFrame. This method checks the height of BudgetPanel#percentageDisplay. If said height is different from BudgetPanel#percentageDisplay#maxHeight, BudgetPanel#percentageDisplay will be rescaled accordingly such that its new width is equal to BudgetPanel#percentageDisplay#maxHeight.

A call to Timeline#playFromStart() is made to execute the animations.

A call is also made concurrently to BudgetPanel#setBudgetUiColors(). If BudgetPanel#expenseDisplay is larger than BudgetPanel#budgetCapDisplay, the color of BudgetPanel#expenseDisplay and BudgetPanel#budgetBar changes to red, indicating that the user is over budget.

The user launches the application for the first time. A new NotificationHandler is instantiated. A new Tips object is instantiated, and a call to JsonTipsStorage#readTips is made to read a list of Tip objects from a JSON file.

A call to NotificationHandler#isTimeToSendTip() is made upon login. In turn, a check is made to see if it has been 24 hours since the last TipNotification has been sent. It also checks if NotificationHandler#isTipEnabled is true. If both conditions are met, a new `TipNotification is added to the NotificationHandler#internalList via a call to NotificationPanel#addTipNotification().

The user executes the command add n/Lunch $/30.00 c/Food. The add command calls NotificationHandler#isTimeToSendWarning() to check if the user is nearing or over their budget. It also checks if NotificationPanel#isWarningEnabled is true. If both conditions are met, a WarningNotification is added to NotificationHandler#internalList via a call to NotificationPanel#addWarningNotification().

If the size of NotificationHandler#internalList reaches 11 or more, the oldest Notification in the list is then replaced with the new Notification.

A call to NotificationCommand#parse is made, which creates a NotificationCommandDescriptor object with the two extracted parameters warning and off. A NotificationCommand is returned to LogicManager.

LogicManager then calls NotificationCommand#execute(), which calls NotificationHandler#toggleWarningNotifications() to set NotificationPanel#isWarningEnabled to false.

User enters command setBudget 2.00.

The command is received by ExpenseTrackerParser, which then creates a SetBudgetCommandParser Object and calls SetBudgetCommandParser#parse() method.

SetBudgetCommandParser#parse() will then return a budget of double type. It will then create a SetBudgetCommand Object with budget as a parameter would be created and returned to LogicManager.

LogicManager then calls SetBudgetCommand#execute(), which calls ModelManager#modifyMaximumBudget to update the maximum budget of Expense Tracker.

LogicManager will then call EventsCenter#post() to update the UI, displaying the updated budget.

User enters command setCategoryBudget c/School b/2.00. The command is received by ExpenseTrackerParser

ExpenseTrackerParser will then create a AddCategoryBudgetCommandParser Object and calls AddCategoryBudgetCommandParser#parse() method.

AddCategoryBudgetCommandParser#parse() method calls ArgumentTokenizer#tokenize() to tokenize the input String into keywords and store them in an ArgumentMultimap Object.

AddCategoryBudgetCommandParser#parse() method then calls AddCategoryBudgetCommandParser#arePrefixesPresent() method. If any of the keywords are missing, ParseException will be thrown.

From the previous step, if no exception is thrown, an AddCategoryBudgetCommand Object with category and budget is created and returned to LogicManager.

LogicManager then calls AddCategoryBudgetCommand#execute(),which calls ModelManager#setCategoryBudget() method to add a CategoryBudget.