Ang Chin Guan, Melvin - Project Portfolio

To execute the tag command, you have to use the following syntax:

tag i/INDEX t/TAG_NAME…​

Assume you have a few transaction entries already inside THRIFT, and one of them is not categorised yet. You want to tag that entry with a meaningful tag.

Here’s how you can do that:

{Start of extract from the section on the tag command}

{Start of extract from the section on the untag command}

To execute the untag command, you have to use the following syntax:

untag i/INDEX t/TAG_NAME…​

Assume you have a few transaction entries already inside THRIFT, and one of them has an incorrect tag. You want to dissociate the incorrect tag from that entry.

Here’s how you can do that:

{End of extract from the section on the untag command}

{Start of extract from the section on the convert command}

To execute the convert command, you have to use the following syntax:

convert [v/VALUE] c/CURRENCY…​

Assume you want an estimate of how much foreign currency you can get with your local currency and you want to do so without leaving THRIFT.

Here’s how you can do that:

{End of extract from the section on the convert command}

The tag/untag command performs modifications on existing Transaction entries that reside in the Model. Implemented using the concept of polymorphism , both Expense and Income objects extend the abstract class Transaction, and are treated the same way in the context of the tag/untag command.

Due to this polymorphic implementation, many of the driver functions in THRIFT use the Transaction class for both Expense and Income objects. For example, when tagging a new Expense/Income object, the TagCommandParser will treat them as the same object:

When a user enters a tag/untag command, it is parsed by the respective TagCommandParser#parse(String args) and UntagCommandParser#parse(String args) parsers and returns a TagCommand command object or a UntagCommand command object respectively, which will be executed. For both commands, the following conditions will cause a ParseException to be thrown by their respective parsers:

The following is an example on how a Tag is added and removed from a Transaction, with details on the processes done in the backend.

Step 1. The user launches the application with data from previous sessions. THRIFT currently contains two Transaction objects and the user is going to perform tagging and un-tagging operations on one of them.

Step 2. The user executes the command tag i/1 t/Delicious to tag the Transaction at Index 1 with the Tag "Delicious". The input is checked with the TagCommandParser parser and an attempt to parse each parameter occurs:

Since the user input is valid, a TagCommand command object is created and executed. As a result, a copy of the Transaction object with the specified Tag added replaces the original in the TransactionList at the same position.

Step 3. The user realises that the Tag added was not appropriate. The user then executes the command untag i/1 t/Delicious to untag the Tag "Delicious" from the Transaction at Index 1. The input is now checked with the UntagCommandParser parser and similarly, an attempt to parse each parameter occurs.

Again, since the user input is valid, a UntagCommand command object is created and executed. As a result, a copy of the Transaction object with the specified Tag deleted replaces the original in the TransactionList at the same position.

The following activity diagram summarises what happens when the user executes a command to tag a Transaction.

The untag command follows the same flow except for the following differences:

Adhering to the Open-Closed principle, we will not modify the existing architecture but extend it. The following class diagram illustrates how we propose to do it, by adding 2 new classes to the existing architecture:

The new classes will have the following roles: