diff --git a/.classpath b/.classpath
index 3f05f311a90b..c999801076cc 100644
--- a/.classpath
+++ b/.classpath
@@ -15,7 +15,7 @@
-
+
diff --git a/.project b/.project
index 1c9339c5f927..f07b7c798f6e 100644
--- a/.project
+++ b/.project
@@ -1,7 +1,7 @@
- addressbook-level4
- Project addressbook-level4 created by Buildship.
+ main-final
+ Project main-final created by Buildship.
@@ -20,4 +20,24 @@
org.eclipse.buildship.core.gradleprojectnature
org.eclipse.jdt.core.javanature
+
+
+ 1478618700355
+
+ 26
+
+ org.eclipse.ui.ide.multiFilter
+ 1.0-projectRelativePath-matches-false-false-build
+
+
+
+ 1478618700593
+
+ 26
+
+ org.eclipse.ui.ide.multiFilter
+ 1.0-projectRelativePath-matches-false-false-.gradle
+
+
+
diff --git a/.settings/gradle.prefs b/.settings/gradle.prefs
new file mode 100644
index 000000000000..2840164a4657
--- /dev/null
+++ b/.settings/gradle.prefs
@@ -0,0 +1,12 @@
+{
+ "1.0": {
+ "project_path": ":",
+ "project_dir": "/Users/ravi/Desktop/main",
+ "connection_project_dir": "/Users/ravi/Desktop/main",
+ "connection_gradle_user_home": null,
+ "connection_gradle_distribution": "GRADLE_DISTRIBUTION(WRAPPER)",
+ "connection_java_home": null,
+ "connection_jvm_arguments": "",
+ "connection_arguments": ""
+ }
+}
\ No newline at end of file
diff --git a/.settings/org.eclipse.buildship.core.prefs b/.settings/org.eclipse.buildship.core.prefs
index 4e0fc71ac89f..a34e7665afa0 100644
--- a/.settings/org.eclipse.buildship.core.prefs
+++ b/.settings/org.eclipse.buildship.core.prefs
@@ -1,3 +1,6 @@
+GRADLE_BUILD_COMMANDS=org.eclipse.jdt.core.javabuilder
+GRADLE_FILTERS=1.0-projectRelativePath-matches-false-false-build,1.0-projectRelativePath-matches-false-false-.gradle
+GRADLE_NATURES=org.eclipse.jdt.core.javanature
build.commands=org.eclipse.jdt.core.javabuilder
connection.arguments=
connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
diff --git a/.travis.yml b/.travis.yml
index a9d9e9b47d87..2fb15bd6ef0b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,4 +10,4 @@ before_install:
addons:
apt:
packages:
- - oracle-java8-installer
+ - oracle-java8-installer
diff --git a/Collate-GUI.jar b/Collate-GUI.jar
new file mode 100644
index 000000000000..3f9e6de8069c
Binary files /dev/null and b/Collate-GUI.jar differ
diff --git a/README.md b/README.md
index 249a00b3899c..f2b87a75bc0d 100644
--- a/README.md
+++ b/README.md
@@ -1,21 +1,13 @@
[](https://travis-ci.org/se-edu/addressbook-level4)
-[](https://coveralls.io/github/se-edu/addressbook-level4?branch=master)
+[](https://coveralls.io/github/CS2103AUG2016-F10-C3/main?branch=master)
+[](https://www.codacy.com/app/shwetha-ravi3/main?utm_source=github.com&utm_medium=referral&utm_content=CS2103AUG2016-F10-C3/main&utm_campaign=Badge_Grade)
-# Address Book (Level 4)
+# Tary
-
+
-* This is a desktop Address Book application. It has a GUI but most of the user interactions happen using
+* This is a desktop GTD (Get things done) application. It has a GUI but most of the user interactions happen using
a CLI (Command Line Interface).
-* It is a Java sample application intended for students learning Software Engineering while using Java as
- the main programming language.
-* It is **written in OOP fashion**. It provides a **reasonably well-written** code example that is
- **significantly bigger** (around 6 KLoC)than what students usually write in beginner-level SE modules.
-* What's different from [level 3](https://github.com/se-edu/addressbook-level3):
- * A more sophisticated GUI that includes a list panel and an in-built Browser.
- * More test cases, including automated GUI testing.
- * Support for *Build Automation* using Gradle and for *Continuous Integration* using Travis CI.
-
#### Site Map
* [User Guide](docs/UserGuide.md)
diff --git a/build.gradle b/build.gradle
index 46b06c1e42ec..d919b55ed8de 100644
--- a/build.gradle
+++ b/build.gradle
@@ -52,6 +52,7 @@ allprojects {
compile "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"
compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jacksonDataTypeVersion"
compile "com.google.guava:guava:$guavaVersion"
+ compile "com.joestelmach:natty:0.7"
testCompile "junit:junit:$junitVersion"
testCompile "org.testfx:testfx-core:$testFxVersion"
@@ -74,10 +75,10 @@ allprojects {
}
shadowJar {
- archiveName = "addressbook.jar"
+ archiveName = "tary.jar"
manifest {
- attributes "Main-Class": "seedu.address.MainApp"
+ attributes "Main-Class": "seedu.gtd.MainApp"
}
destinationDir = file("${buildDir}/jar/")
@@ -138,7 +139,7 @@ task guiTests(type: AddressBookTest) {
task nonGuiTests(type: AddressBookTest) {
- include 'seedu/address/**'
+ include 'seedu/gtd/**'
jacoco {
destinationFile = new File("${buildDir}/jacoco/test.exec")
diff --git a/collated/docs/A0130677A.md b/collated/docs/A0130677A.md
new file mode 100644
index 000000000000..d0de4c459d1d
--- /dev/null
+++ b/collated/docs/A0130677A.md
@@ -0,0 +1,148 @@
+# A0130677A
+###### /UserGuide.md
+``` md
+
+### Adding a person: `add`
+**Format:** `add NAME [a/LOCATION s/START_DATE d/DEADLINE_OR_END_DATE p/PRIORITY t/TAGS]`
+* Adds a task to the task list in a flexible format (in any order).
+* All parameters except name are optional.
+* This command supports 3 types of tasks: floating tasks, event tasks and deadline tasks.
+* Persons can have any number of tags (including 0)
+
+Examples:
+* Floating task: `add Visit Dentist`
+* Event task: `add hackathon a/NUS s/tomorrow d/sunday p/3 t/preparation`
+* Deadline task: `add submit tutorial d/monday p/5`
+
+**Field Type Constraints**
+* Task duedate or startdate is formatted like the following: Wed Nov 02 15:39:55 UTC 2016
+* Accepted formal dates: 1978-01-28, 1984/04/02, 1/02/1980, 2/28/79
+* Relaxed dates: The 31st of April in the year 2008, Fri, 21 Nov 1997, Jan 21, '97, Sun, Nov 21, jan 1st, february twenty-eighth
+* Relative dates: next thursday, last wednesday, today, tomorrow, yesterday, next week, next month, next year, 3 days from * now, three weeks ago
+* Prefixes: day after, the day before, the monday after, the monday before, 2 fridays before, 4 tuesdays after
+* Time: 0600h, 06:00 hours, 6pm, 5:30 a.m., 5, 12:59, 23:59, 8p, noon, afternoon, midnight
+* Relative times: 10 seconds ago, in 5 minutes, 4 minutes from now.
+
+
+### Mark task as done : `done`
+Format: `done INDEX`
+Marks a task as done by the index displayed on the task panel.
+* tasks marked as done can be shown when using command 'list done'
+* once marked as done, cannot be undone unless using `undone` command immediately
+
+
+### Edit task by attributes: `edit`
+Format: `edit INDEX [NEW_NAME] FIELD_TYPE/NEW_FIELD_DETAILS`
+Edits a task as done by the index displayed on the task panel.
+* to change the name only, use `edit NEW_NAME` without specifying field type
+* able to accept multiple field types e.g. `edit 2 taskA a/NUS d/friday`
+
+
+### Undo previous command: `undo`
+Format: `undo`
+Undo the last command.
+* multiple undos supported.
+
+
+### Listing all tasks : `list`
+Format: `list [done]`
+Shows a list of all tasks done or not done in the task list.
+* `list` shows all tasks not done
+* `list done` shows all tasks done
+
+
+### Finding all tasks containing any keyword in their name or attributes: `find`
+Format: `find [FIELD_TYPE] KEYWORD`
+Finds tasks whose descriptions contain any of the given keyword.
+* The search is case sensitive. e.g `hmk` will not match `HMK`
+* The order of the keywords does not matter. e.g. `Do Homework` will match `Homework Do`
+* If field type is specified, only the field type will be matched with the keyword
+* If field type is not specified, name will be search for a match first, before searching all the other fields for the keyword.
+* Only full words will be matched e.g. `Hmk` will not match `Hmks`
+* Tasks matching at least one keyword will be returned (i.e. `OR` search).
+ e.g. `Hmk` will match `Do Hmk`
+
+Examples:
+* `find p/3` : Returns any task that has priority 3
+* `find a/NUS` : Returns any task that occurs in NUS
+* `find homework`: Returns task with homework in the name, if not found, returns tasks with homework in other fields such as tags
+
+
+### Deleting a task : `delete`
+Deletes the specified task from the address book. Irreversible.
+Format: `delete INDEX`
+
+Deletes the task at the specified `INDEX`.
+The index refers to the index number shown in the most recent listing.
+The index **must be a positive integer** 1, 2, 3, ...
+
+Examples:
+* `list`
+ `delete 2`
+ Deletes the 2nd task in the task list.
+* `find CS2101`
+ `delete 1`
+ Deletes the 1st task in the results of the `find` command.
+
+
+### Select a person : `select`
+Selects the person identified by the index number used in the last person listing.
+Format: `select INDEX`
+
+Selects the person and loads the Google Maps for location of the task at the specified `INDEX`.
+The index refers to the index number shown in the most recent listing.
+The index **must be a positive integer** 1, 2, 3, ...
+
+Examples:
+* `list`
+ `select 2`
+ Selects the 2nd task in the task list.
+* `find a/NUS`
+ `select 1`
+ Selects the 1st task in the results of the `find` command.
+
+
+### Clearing all entries : `clear`
+Clears all entries from the task list.
+Format: `clear`
+
+
+### Change file path of storage : `setPath`
+Change the path of the task list to be stored to the specified file path.
+Format: `setPath NEW_PATH`
+Example:
+* `setPath data/newfilepath.xml`
+
+
+### Exiting the program : `exit`
+Exits the program.
+Format: `exit`
+
+
+### Saving the data
+Task List data are saved in the hard disk automatically after any command that changes the data.
+There is no need to save manually.
+
+
+## FAQ
+
+**Q**: How do I transfer my data to another Computer?
+**A**: Install the app in the other computer and overwrite the empty data file it creates with
+ the file that contains the data of your previous Tasks folder.
+
+## Command Summary
+
+Command | Format
+-------- | :--------
+Add | `add NAME [s/startdate d/duedate a/address p/priorityrank(1- highest,5-lowest) t/TAG]...`
+Edit | `edit INDEX [NEW_NAME] FIELD_TYPE/NEW_FIELD_DETAILS` where FIELD_TYPE is either `d/` `a/` `s/` `p/`
+Done | `done INDEX`
+Clear | `clear`
+Delete | `delete INDEX`
+Find | `find [FIELD_TYPE] KEYWORD` FIELD_TYPE options: `t/` `a/` `s/` `d/` `p/`
+List | `list [done]`
+Help | `help`
+Select | `select INDEX`
+SetPath | `setPath NEW_FILE_PATH` NEW_FILE_PATH: e.g. `data/newfile.xml`
+Exit | `exit`
+```
diff --git a/collated/docs/A0139072H.md b/collated/docs/A0139072H.md
new file mode 100644
index 000000000000..9f6f7cd12314
--- /dev/null
+++ b/collated/docs/A0139072H.md
@@ -0,0 +1,37 @@
+# A0139072H
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
+###### /DeveloperGuide.md
+``` md
+
+```
diff --git a/collated/docs/A0146130W.md b/collated/docs/A0146130W.md
new file mode 100644
index 000000000000..0c167fad9ea8
--- /dev/null
+++ b/collated/docs/A0146130W.md
@@ -0,0 +1,51 @@
+# A0146130W
+###### /DeveloperGuide.md
+``` md
+
+## Appendix A : User Stories
+
+Priorities: High (must have) - `* * *`, Medium (nice to have) - `* *`, Low (unlikely to have) - `*`
+
+Priority | As a ... | I want to ... | So that I can...
+-------- | :-------- | :--------- | :-----------
+`* * *` | new user | see usage instructions | refer to instructions when I forget how to use the application
+`* * *` | user | add a task with a deadline | be reminded of tasks that I have to complete soon and prioritise them
+`* * ` | user | add a task with a priority rank | view a prioritised list of tasks and know which task to start with
+`* * ` | user | add a task with a location | immediately know the location and context without having to refer to other sources
+`* * *` | user | add a task with tag(s) | search or filter tasks by these tags
+`* * ` | user | select a task to access widgets like Google Calendar and Google Maps | immediately connect with these frequently used applications, without having to take more steps such as opening a browser and visiting the link, and typing in the search bar
+`* * *` | user | delete a task | remove clutter from the task list
+`* * *` | user | find a task by title | find tasks easily
+`* * *` | user | find a task by tags | categorise and find tasks easily
+`* * *` | user | edit information about a task | update the task (such as adding a deadline or location) when more information is available or when changes arise
+`* * *` | user | view all tasks entered | have a quick summary of what tasks I have
+`* * *` | user | clear all tasks | reset the task list
+
+```
+###### /DeveloperGuide.md
+``` md
+
+## Appendix E : Product Survey
+
+Reminders for Mac: Simple, clean white interface that is close to a text editor. Mouse use for interaction only required for tags, adding and deleting.
+Features:
+a) tags can be added to items on the list like date due and priority
+b) schedule tab can arrange the reminders by due date
+c) iCloud sync allows use on laptop and phone
+d) periodic tasks can be set such that a reminder alert is displayed every time it is due.
+
+Drawbacks:
+a) Need to refer to calendar to set due dates.
+
+Asana: Collaborative GTD, a team can set up project tasks and subgroups that divide people into smaller groups based on tasks (Marketing, Engineering, etc).
+a) Can setup individual tasks on personal dashboard, so it also works well for individual use.
+b) Can hold conversations with team members.
+c) Can set up team tasks.
+d) Can divide members into smaller groups for better organisation.
+
+Taskwarrior: feature-rich software that allows the user to manage his todo list from the command line.
+Uses a natural and expressive syntax
+Allows user to perform CRUD functions and prioritising of tasks in a fast manner
+Support for creating deadlines, searching of tasks
+However, it does not support Jim’s need for “blocking� and “unblocking� timeslots
+```
diff --git a/collated/docs/addressbooklevel4.md b/collated/docs/addressbooklevel4.md
new file mode 100644
index 000000000000..f7f93106178c
--- /dev/null
+++ b/collated/docs/addressbooklevel4.md
@@ -0,0 +1,258 @@
+# addressbooklevel4
+###### /DeveloperGuide.md
+``` md
+The **_Architecture Diagram_** given above explains the high-level design of the App.
+Given below is a quick overview of each component.
+
+`Main` has only one class called [`MainApp`](../src/main/java/seedu/address/MainApp.java). It is responsible for,
+* At app launch: Initializes the components in the correct sequence, and connect them up with each other.
+* At shut down: Shuts down the components and invoke cleanup method where necessary.
+
+[**`Commons`**](#common-classes) represents a collection of classes used by multiple other components.
+Two of those classes play important roles at the architecture level.
+* `EventsCentre` : This class (written using [Google's Event Bus library](https://github.com/google/guava/wiki/EventBusExplained))
+ is used by components to communicate with other components using events (i.e. a form of _Event Driven_ design)
+* `LogsCenter` : Used by many classes to write log messages to the App's log file.
+
+The rest of the App consists four components.
+* [**`UI`**](#ui-component) : The UI of tha App.
+* [**`Logic`**](#logic-component) : The command executor.
+* [**`Model`**](#model-component) : Holds the data of the App in-memory.
+* [**`Storage`**](#storage-component) : Reads data from, and writes data to, the hard disk.
+
+Each of the four components
+* Defines its _API_ in an `interface` with the same name as the Component.
+* Exposes its functionality using a `{Component Name}Manager` class.
+
+For example, the `Logic` component (see the class diagram given below) defines it's API in the `Logic.java`
+interface and exposes its functionality using the `LogicManager.java` class.
+```
+###### /DeveloperGuide.md
+``` md
+
+The _Sequence Diagram_ below shows how the components interact for the scenario where the user issues the
+command `delete 3`.
+```
+###### /DeveloperGuide.md
+``` md
+
+>Note how the `Model` simply raises a `AddressBookChangedEvent` when the GTD data are changed,
+ instead of asking the `Storage` to save the updates to the hard disk.
+
+The diagram below shows how the `EventsCenter` reacts to that event, which eventually results in the updates
+being saved to the hard disk and the status bar of the UI being updated to reflect the 'Last Updated' time.
+```
+###### /DeveloperGuide.md
+``` md
+
+> Note how the event is propagated through the `EventsCenter` to the `Storage` and `UI` without `Model` having
+ to be coupled to either of them. This is an example of how this Event Driven approach helps us reduce direct
+ coupling between components.
+
+The sections below give more details of each component.
+
+### UI component
+```
+###### /DeveloperGuide.md
+``` md
+
+**API** : [`Ui.java`](../src/main/java/seedu/address/ui/Ui.java)
+
+The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `TaskListPanel`,
+`StatusBarFooter`, `BrowserPanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class
+and they can be loaded using the `UiPartLoader`.
+
+The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files
+ that are in the `src/main/resources/view` folder.
+ For example, the layout of the [`MainWindow`](../src/main/java/seedu/address/ui/MainWindow.java) is specified in
+ [`MainWindow.fxml`](../src/main/resources/view/MainWindow.fxml)
+
+The `UI` component,
+* Executes user commands using the `Logic` component.
+* Binds itself to some data in the `Model` so that the UI can auto-update when data in the `Model` change.
+* Responds to events raised from various parts of the App and updates the UI accordingly.
+
+### Logic component
+```
+###### /DeveloperGuide.md
+``` md
+**API** : [`Logic.java`](../src/main/java/seedu/address/logic/Logic.java)
+
+1. `Logic` uses the `Parser` class to parse the user command.
+2. This results in a `Command` object which is executed by the `LogicManager`.
+3. The command execution can affect the `Model` (e.g. adding a task) and/or raise events.
+4. The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
+
+Given below is the Sequence Diagram for interactions within the `Logic` component for the `execute("delete 1")`
+ API call.
+```
+###### /DeveloperGuide.md
+``` md
+### Model component
+```
+###### /DeveloperGuide.md
+``` md
+**API** : [`Model.java`](../src/main/java/seedu/address/model/Model.java)
+
+The `Model`,
+* stores a `UserPref` object that represents the user's preferences.
+* stores the GTD data.
+* exposes a `UnmodifiableObservableList` that can be 'observed' e.g. the UI can be bound to this list
+ so that the UI automatically updates when the data in the list change.
+* does not depend on any of the other three components.
+
+### Storage component
+```
+###### /DeveloperGuide.md
+``` md
+**API** : [`Storage.java`](../src/main/java/seedu/address/storage/Storage.java)
+
+The `Storage` component,
+* can save `UserPref` objects in json format and read it back.
+* can save the GTD data in xml format and read it back.
+
+### Common classes
+
+Classes used by multiple components are in the `seedu.addressbook.commons` package.
+
+## Implementation
+
+### Logging
+
+We are using `java.util.logging` package for logging. The `LogsCenter` class is used to manage the logging levels
+and logging destinations.
+
+* The logging level can be controlled using the `logLevel` setting in the configuration file
+ (See [Configuration](#configuration))
+* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)` which will log messages according to
+ the specified logging level
+* Currently log messages are output through: `Console` and to a `.log` file.
+
+**Logging Levels**
+
+* `SEVERE` : Critical problem detected which may possibly cause the termination of the application
+* `WARNING` : Can continue, but with caution
+* `INFO` : Information showing the noteworthy actions by the App
+* `FINE` : Details that is not usually noteworthy but may be useful in debugging
+ e.g. print the actual list instead of just its size
+
+### Configuration
+
+Certain properties of the application can be controlled (e.g App name, logging level) through the configuration file
+(default: `config.json`):
+
+
+## Testing
+
+Tests can be found in the `./src/test/java` folder.
+
+**In Eclipse**:
+> If you are not using a recent Eclipse version (i.e. _Neon_ or later), enable assertions in JUnit tests
+ as described [here](http://stackoverflow.com/questions/2522897/eclipse-junit-ea-vm-option).
+
+* To run all tests, right-click on the `src/test/java` folder and choose
+ `Run as` > `JUnit Test`
+* To run a subset of tests, you can right-click on a test package, test class, or a test and choose
+ to run as a JUnit test.
+
+**Using Gradle**:
+* See [UsingGradle.md](UsingGradle.md) for how to run tests using Gradle.
+
+We have two types of tests:
+
+1. **GUI Tests** - These are _System Tests_ that test the entire App by simulating user actions on the GUI.
+ These are in the `guitests` package.
+
+2. **Non-GUI Tests** - These are tests not involving the GUI. They include,
+ 1. _Unit tests_ targeting the lowest level methods/classes.
+ e.g. `seedu.address.commons.UrlUtilTest`
+ 2. _Integration tests_ that are checking the integration of multiple code units
+ (those code units are assumed to be working).
+ e.g. `seedu.address.storage.StorageManagerTest`
+ 3. Hybrids of unit and integration tests. These test are checking multiple code units as well as
+ how the are connected together.
+ e.g. `seedu.address.logic.LogicManagerTest`
+
+**Headless GUI Testing** :
+Thanks to the [TestFX](https://github.com/TestFX/TestFX) library we use,
+ our GUI tests can be run in the _headless_ mode.
+ In the headless mode, GUI tests do not show up on the screen.
+ That means the developer can do other things on the Computer while the tests are running.
+ See [UsingGradle.md](UsingGradle.md#running-tests) to learn how to run tests in headless mode.
+
+## Dev Ops
+
+### Build Automation
+
+See [UsingGradle.md](UsingGradle.md) to learn how to use Gradle for build automation.
+
+### Continuous Integration
+
+We use [Travis CI](https://travis-ci.org/) to perform _Continuous Integration_ on our projects.
+See [UsingTravis.md](UsingTravis.md) for more details.
+
+### Making a Release
+
+Here are the steps to create a new release.
+
+ 1. Generate a JAR file [using Gradle](UsingGradle.md#creating-the-jar-file).
+ 2. Tag the repo with the version number. e.g. `v0.1`
+ 2. [Crete a new release using GitHub](https://help.github.com/articles/creating-releases/)
+ and upload the JAR file your created.
+
+### Managing Dependencies
+
+A project often depends on third-party libraries. For example, Tarydepends on the
+[Jackson library](http://wiki.fasterxml.com/JacksonHome) for XML parsing. Managing these _dependencies_
+can be automated using Gradle. For example, Gradle can download the dependencies automatically, which
+is better than these alternatives.
+a. Include those libraries in the repo (this bloats the repo size)
+b. Require developers to download those libraries manually (this creates extra work for developers)
+
+```
+###### /DeveloperGuide.md
+``` md
+
+## Appendix B : Use Cases
+
+(For all use cases below, the **System** is the `GTD` and the **Actor** is the `user`, unless specified otherwise)
+
+#### Use case: Delete task
+
+**MSS**
+
+1. User requests to list persons
+2. GTD shows a list of persons
+3. User requests to delete a specific person in the list
+4. GTD deletes the person
+Use case ends.
+
+**Extensions**
+
+2a. The list is empty
+
+> Use case ends
+
+3a. The given index is invalid
+
+> 3a1. GTD shows an error message
+ Use case resumes at step 2
+
+{More to be added}
+
+## Appendix C : Non Functional Requirements
+
+1. Should work on any [mainstream OS](#mainstream-os) as long as it has Java `1.8.0_60` or higher installed.
+2. Should be able to hold up to 10,000 tasks.
+3. Should come with automated unit tests and open source code.
+4. Should favor DOS style commands over Unix-style commands.
+
+{More to be added}
+
+## Appendix D : Glossary
+
+##### Mainstream OS
+
+> Windows, Linux, Unix, OS-X
+
+```
diff --git a/collated/main/A0130677A.md b/collated/main/A0130677A.md
new file mode 100644
index 000000000000..ceaf8f652bae
--- /dev/null
+++ b/collated/main/A0130677A.md
@@ -0,0 +1,638 @@
+# A0130677A
+###### /seedu/gtd/logic/commands/AddCommand.java
+``` java
+public class AddCommand extends Command {
+
+ public static final String COMMAND_WORD = "add";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Adds a task to the GTD. "
+ + "Parameters: NAME [s/STARTDATE d/DUEDATE a/ADDRESS p/PRIORITY t/TAGS]...\n"
+ + "All parameters except name is optional.\n"
+ + "Example: " + COMMAND_WORD
+ + " Do CS2103 Tutorial 4 d/noon a/NUS p/3 t/CS2103 tutorial fun";
+
+ public static final String MESSAGE_SUCCESS = "New task added: %1$s";
+ public static final String MESSAGE_DUPLICATE_TASK = "This task already exists in the task list";
+
+ private final Task toAdd;
+
+ /**
+ * Convenience constructor using raw values.
+ *
+ * @throws IllegalValueException if any of the raw values are invalid
+ */
+ public AddCommand(String name, String startDate, String dueDate, String address, String priority, Set tags)
+ throws IllegalValueException {
+ final Set tagSet = new HashSet<>();
+ for (String tagName : tags) {
+ tagSet.add(new Tag(tagName));
+ }
+ this.toAdd = new Task(
+ new Name(name),
+ new DueDate(startDate),
+ new DueDate(dueDate),
+ new Address(address),
+ new Priority(priority),
+ new UniqueTagList(tagSet)
+ );
+ }
+
+```
+###### /seedu/gtd/logic/commands/DoneCommand.java
+``` java
+public class DoneCommand extends Command {
+
+ public static final String COMMAND_WORD = "done";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD
+ + ": Marks a task as done, by the index number used in the last task listing.\n"
+ + "Parameters: INDEX (must be a positive integer)\n"
+ + "Example: " + COMMAND_WORD + " 1";
+
+ public static final String MESSAGE_DONE_TASK_SUCCESS = "Done Task: %1$s";
+
+ public final int targetIndex;
+
+ public DoneCommand(int targetIndex) {
+ this.targetIndex = targetIndex;
+ }
+
+
+ @Override
+ public CommandResult execute() {
+
+ UnmodifiableObservableList lastShownList = model.getFilteredTaskList();
+
+ if (lastShownList.size() < targetIndex) {
+ indicateAttemptToExecuteIncorrectCommand();
+ return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+ }
+
+ ReadOnlyTask toEdit = lastShownList.get(targetIndex-1);
+ Task taskToUpdate = new Task(toEdit);
+
+ try {
+ taskToUpdate = updateTask(taskToUpdate, "done", "true");
+ } catch (IllegalValueException ive) {
+ return new CommandResult(ive.getMessage());
+ }
+
+ assert model != null;
+ try {
+ System.out.println("in donecommand.java");
+ System.out.println(taskToUpdate.getName() + " " + taskToUpdate.getisDone());
+ System.out.println("index at donecommand:" + targetIndex);
+ model.doneTask(targetIndex-1, taskToUpdate);
+
+ } catch (TaskNotFoundException e) {
+ assert false : "The target task cannot be missing";
+ }
+ return new CommandResult(String.format(MESSAGE_DONE_TASK_SUCCESS, taskToUpdate));
+
+ }
+
+ private Task updateTask(Task taskToUpdate, String detailType, String newDetail) throws IllegalValueException {
+ taskToUpdate.edit(detailType, newDetail);
+ return taskToUpdate;
+ }
+
+}
+```
+###### /seedu/gtd/logic/commands/FindCommand.java
+``` java
+public class FindCommand extends Command {
+ public static final String COMMAND_WORD = "find";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Finds all tasks whose name, date, address, tags and priority contain any of "
+ + "the specified keywords (case-sensitive) and displays them as a list with index numbers.\n"
+ + "To search by one particular field type, use t/ for tags, a/ for address, d/ for duedate and p/ for priority.\n"
+ + "Parameters: [FIELDTYPE] KEYWORD [MORE_KEYWORDS]...\n"
+ + "Example: " + COMMAND_WORD + " cs2103, " + COMMAND_WORD + " d/today";
+
+```
+###### /seedu/gtd/logic/commands/FindCommand.java
+``` java
+ @Override
+ public CommandResult execute() {
+ System.out.println("command: " + cmd);
+
+ // search by parameter if specified
+ if (cmd != "nil") {
+ model.updateFilteredTaskList(keywords, cmd);
+ } else {
+ // search by exact name
+ model.updateFilteredTaskList(keywords, keywordSet);
+ }
+ if (!model.getFilteredTaskList().isEmpty()) {
+ return new CommandResult(getMessageForTaskListShownSummary(model.getFilteredTaskList().size()));
+ }
+
+ // search by keywords
+ model.updateFilteredTaskList(keywords, "nil");
+
+ if (!model.getFilteredTaskList().isEmpty()) {
+ if (cmd == "nil") {
+ return new CommandResult(getMessageForTaskListShownSummaryIfExactPhraseNotFound(model.getFilteredTaskList().size()));
+ } else {
+ return new CommandResult(getMessageForTaskListShownSummaryIfExactFieldNotFound(model.getFilteredTaskList().size()));
+ }
+ }
+
+ return new CommandResult(getMessageForTaskListShownSummary(model.getFilteredTaskList().size()));
+ }
+}
+```
+###### /seedu/gtd/logic/commands/ListCommand.java
+``` java
+
+public class ListCommand extends Command {
+
+ public static final String COMMAND_WORD = "list";
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Shows a list of all tasks in the task list.";
+ public static final String MESSAGE_SUCCESS_LIST = "Listed all undone tasks";
+ public static final String MESSAGE_SUCCESS_LIST_DONE = "Listed all tasks done";
+ private String arg;
+
+ public ListCommand(String arg) {
+ this.arg = arg;
+ }
+
+ @Override
+ public CommandResult execute() {
+ System.out.println("args:" + arg);
+ if (arg.equals(" done")) {
+ System.out.println("in done");
+ model.updateFilteredListToShowRemoved();
+ return new CommandResult(MESSAGE_SUCCESS_LIST_DONE);
+ } else {
+ model.updateFilteredListToShowUndone();
+ return new CommandResult(MESSAGE_SUCCESS_LIST);
+ }
+ }
+}
+```
+###### /seedu/gtd/logic/parser/DateNaturalLanguageProcessor.java
+``` java
+ public Date getDate(String naturalLanguageDate) {
+ List dateGroups = parser.parse(naturalLanguageDate);
+ Date parsedDate;
+ try {
+ parsedDate = refineDateGroupList(dateGroups);
+ return parsedDate;
+ } catch (NaturalLanguageException e) {
+ return null;
+ }
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private static final Pattern NAME_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile("(?[^/]+) (s|t|p|a|d|z)/.*");
+
+ private static final Pattern PRIORITY_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* p/(?[^/]+) (s|t|a|d|z)/.*");
+
+ private static final Pattern ADDRESS_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* a/(?[^/]+) (s|t|p|d|z)/.*");
+
+ private static final Pattern STARTDATE_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* s/(?[^/]+) (d|t|a|p|z)/.*");
+
+ private static final Pattern DUEDATE_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* d/(?[^/]+) (s|t|a|p|z)/.*");
+
+ private static final Pattern TAGS_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* t/(?[^/]+) (s|d|a|p|z)/.*");
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private Command prepareAdd(String args){
+ String preprocessedArg = appendEnd(args.trim());
+
+ final Matcher nameMatcher = NAME_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher startDateMatcher = STARTDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher dueDateMatcher = DUEDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher addressMatcher = ADDRESS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher priorityMatcher = PRIORITY_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher tagsMatcher = TAGS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+
+ String nameToAdd = checkEmptyAndAddDefault(nameMatcher, "name", "nil");
+ String startDateToAdd = checkEmptyAndAddDefault(startDateMatcher, "startDate", "nil");
+ String dueDateToAdd = checkEmptyAndAddDefault(dueDateMatcher, "dueDate", "nil");
+ String addressToAdd = checkEmptyAndAddDefault(addressMatcher, "address", "nil");
+ String priorityToAdd = checkEmptyAndAddDefault(priorityMatcher, "priority", "1");
+
+ // format date if due date or start date is specified
+
+ Date dueDateInDateFormat = null;
+ Date startDateInDateFormat = null;
+
+ if (dueDateMatcher.matches()) {
+ dueDateInDateFormat = getDateInDateFormat(dueDateToAdd);
+ dueDateToAdd = parseDueDate(dueDateToAdd);
+ System.out.println(dueDateInDateFormat);
+ }
+
+ if (startDateMatcher.matches()) {
+ startDateInDateFormat = getDateInDateFormat(startDateToAdd);
+ startDateToAdd = parseDueDate(startDateToAdd);
+ }
+
+ // check that end date is strictly later than start date
+
+ if (dueDateInDateFormat != null && startDateInDateFormat != null
+ && dueDateInDateFormat.compareTo(startDateInDateFormat) < 0) {
+ return new IncorrectCommand(START_END_DATE_INVALID_COMMAND_FORMAT);
+ }
+
+ Set tagsProcessed = Collections.emptySet();
+
+ if (tagsMatcher.matches()) {
+ tagsProcessed = getTagsFromArgs(tagsMatcher.group("tagArguments"));
+ }
+
+
+ // Validate arg string format
+ if (!nameMatcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE));
+ }
+
+ try {
+ return new AddCommand(
+ nameToAdd,
+ startDateToAdd,
+ dueDateToAdd,
+ addressToAdd,
+ priorityToAdd,
+ tagsProcessed
+ );
+ } catch (IllegalValueException ive) {
+ return new IncorrectCommand(ive.getMessage());
+ }
+ }
+
+ private String appendEnd(String args) {
+ return args + " z/";
+ }
+
+ private String checkEmptyAndAddDefault(Matcher matcher, String groupName, String defaultValue) {
+ if (matcher.matches()) {
+ return matcher.group(groupName);
+ } else {
+ return defaultValue;
+ }
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private Date getDateInDateFormat(String dueDateRaw) {
+ NaturalLanguageProcessor nlp = new DateNaturalLanguageProcessor();
+ return nlp.getDate(dueDateRaw);
+ }
+
+ // remove time on date parsed to improve search results
+ private String removeTimeOnDate(String dueDateRaw) {
+ String[] dateTime = dueDateRaw.split(" ");
+ return dateTime[0];
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private Command prepareDone(String args) {
+
+ Optional index = parseIndex(args);
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, DoneCommand.MESSAGE_USAGE));
+ }
+
+ return new DoneCommand(index.get());
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ private Command prepareFind(String args) {
+
+ // check if parameters are specified and pass specified field to FindCommand
+
+ String preprocessedArgs = " " + appendEnd(args.trim());
+ final Matcher addressMatcher = ADDRESS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher priorityMatcher = PRIORITY_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher startDateMatcher = STARTDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher dueDateMatcher = DUEDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher tagsMatcher = TAGS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+
+ Set defaultSet = new HashSet();
+
+ if (addressMatcher.matches()) {
+ String addressToBeFound = addressMatcher.group("address");
+ return new FindCommand(addressToBeFound, defaultSet,"address");
+ }
+ if (priorityMatcher.matches()) {
+ String priorityToBeFound = priorityMatcher.group("priority");
+ return new FindCommand(priorityToBeFound, defaultSet, "priority");
+ }
+ if (startDateMatcher.matches()) {
+ String dueDateToBeFound = dueDateMatcher.group("startDate");
+ String parsedDueDateToBeFound = removeTimeOnDate(parseDueDate(dueDateToBeFound));
+ return new FindCommand(parsedDueDateToBeFound, defaultSet, "startDate");
+ }
+ if (dueDateMatcher.matches()) {
+ String dueDateToBeFound = dueDateMatcher.group("dueDate");
+ String parsedDueDateToBeFound = removeTimeOnDate(parseDueDate(dueDateToBeFound));
+ return new FindCommand(parsedDueDateToBeFound, defaultSet, "dueDate");
+ }
+ if (tagsMatcher.matches()) {
+ String tagsToBeFound = tagsMatcher.group("tagArguments");
+ return new FindCommand(tagsToBeFound, defaultSet,"tagArguments");
+ }
+
+ // free-form search by keywords
+
+ final Matcher matcher = KEYWORDS_ARGS_FORMAT.matcher(args.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+ FindCommand.MESSAGE_USAGE));
+ }
+
+ // keywords delimited by whitespace
+ final String[] splitKeywords = matcher.group("keywords").split("\\s+");
+ final Set keywordSet = new HashSet<>(Arrays.asList(splitKeywords));
+
+ final String keywords = matcher.group("keywords");
+ return new FindCommand(keywords, keywordSet, "nil");
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+
+ @Override
+ public synchronized void doneTask(int targetIndex, Task task) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ addressBook.doneTask(targetIndex, task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+
+ @Override
+ public void updateFilteredListToShowAll() {
+ filteredTasks.setPredicate(null);
+ updateFilteredListToShowAll(new PredicateExpression(new AllQualifiers()));
+ //updateFilteredListToShowAll(null);
+ System.out.println("show all");
+ }
+
+ private void updateFilteredListToShowAll(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ @Override
+ public void updateFilteredListToShowRemoved() {
+ updateFilteredListToShowRemoved(new PredicateExpression(new DoneQualifier()));
+ }
+
+ private void updateFilteredListToShowRemoved(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ @Override
+ public void updateFilteredListToShowUndone() {
+ updateFilteredListToShowUndone(new PredicateExpression(new RemoveDoneQualifier()));
+ }
+
+ private void updateFilteredListToShowUndone(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ @Override
+ public void updateFilteredTaskList(Set keywordSet) {
+ updateFilteredTaskList(new PredicateExpression(new NameQualifier(keywordSet)));
+ }
+
+ @Override
+ public void updateFilteredTaskList(String keywords, Set keywordSet){
+ updateFilteredTaskList(new PredicateExpression(new orderedNameQualifier(keywords, keywordSet)));
+ }
+
+ @Override
+ public void updateFilteredTaskList(String keywords, String cmd) {
+ updateFilteredTaskList(new PredicateExpression(new otherFieldsQualifier(keywords, cmd)));
+ }
+
+ private void updateFilteredTaskList(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ //========== Inner classes/interfaces used for filtering ==================================================
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+
+ private class otherFieldsQualifier implements Qualifier {
+ protected String nameKeyWords;
+ protected String cmd;
+
+ otherFieldsQualifier(String keywords, String cmd) {
+ this.nameKeyWords = keywords;
+ this.cmd = cmd;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ if (cmd == "address") {
+ System.out.println("finding address..");
+ String address = task.getAddress().toString().toLowerCase();
+ boolean addressMatch = address.contains(nameKeyWords.toLowerCase());
+ return addressMatch;
+ } else if (cmd == "priority") {
+ System.out.println("finding priority..");
+ String priority = task.getPriority().toString();
+ boolean priorityMatch = priority.contains(nameKeyWords);
+ return priorityMatch;
+ } else if (cmd == "dueDate") {
+ System.out.println("finding dueDate..");
+ String dueDate = task.getDueDate().toString();
+ boolean dueDateMatch = dueDate.contains(nameKeyWords);
+ return dueDateMatch;
+ } else if (cmd == "tagArguments") {
+ System.out.println("finding tags.. ");
+ UniqueTagList tagsList = task.getTags();
+ boolean tagsMatch = tagsList.containSearch(nameKeyWords.toLowerCase());
+ return tagsMatch;
+ }
+
+ // cmd == "nil"
+
+ String taskFullNameLowerCase = task.getName().fullName.toLowerCase();
+ String priority = task.getPriority().toString();
+ String address = task.getAddress().toString().toLowerCase();
+ String dueDate = task.getDueDate().toString();
+ UniqueTagList tagsList = task.getTags();
+
+ boolean nameMatch = taskFullNameLowerCase.contains(nameKeyWords.toLowerCase());
+ boolean addressMatch = address.contains(nameKeyWords.toLowerCase());
+ boolean priorityMatch = priority.contains(nameKeyWords);
+ boolean dueDateMatch = dueDate.contains(nameKeyWords);
+ boolean tagsMatch = tagsList.containSearch(nameKeyWords.toLowerCase());
+ boolean eachWordMatch = false;
+
+ String[] eachWord = nameKeyWords.split(" ");
+ for (String word : eachWord) {
+ System.out.println("each: " + word);
+ eachWordMatch = eachWordMatch || taskFullNameLowerCase.contains(word.toLowerCase());
+ }
+
+ return eachWordMatch || nameMatch || addressMatch || priorityMatch || dueDateMatch || tagsMatch;
+ }
+ }
+
+ private class orderedNameQualifier extends NameQualifier implements Qualifier {
+ private String nameKeyWords;
+
+ orderedNameQualifier(String keywords, Set keywordSet) {
+ super(keywordSet);
+ this.nameKeyWords = keywords;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ String taskFullNameLowerCase = task.getName().fullName.toLowerCase();
+ boolean nameMatch = taskFullNameLowerCase.contains(nameKeyWords.toLowerCase());
+
+ boolean eachWordMatch = keywordSet.stream()
+ .filter(keyword -> StringUtil.containsIgnoreCase(task.getName().fullName, keyword))
+ .findAny()
+ .isPresent();
+ return eachWordMatch && nameMatch;
+ }
+ }
+ private class AllQualifiers implements Qualifier {
+
+ AllQualifiers() {}
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ return true;
+ }
+ }
+
+ // to check and return a list of tasks that are already done
+ private class DoneQualifier implements Qualifier {
+
+ DoneQualifier() {}
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ return task.getisDone();
+ }
+ }
+
+ // default display tasks that are not yet done
+ private class RemoveDoneQualifier implements Qualifier {
+
+ RemoveDoneQualifier() {}
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ System.out.println(task.getName());
+ return !task.getisDone();
+ //return task.getisDone();
+
+ }
+ }
+ @Override
+```
+###### /seedu/gtd/model/task/Priority.java
+``` java
+ public static final String MESSAGE_PRIORITY_CONSTRAINTS = "Task priority number should only contain a number from 1 to 5";
+ public static final String PRIORITY_VALIDATION_REGEX = "\\d{1}";
+ public static final int MAX_PRIORITY = 5;
+ public static final int MIN_PRIORITY = 1;
+
+```
+###### /seedu/gtd/model/task/Priority.java
+``` java
+ public static boolean isValidPriority(String test) {
+ return test.matches(PRIORITY_VALIDATION_REGEX) &&
+ Integer.parseInt(test) >= MIN_PRIORITY && Integer.parseInt(test) <= MAX_PRIORITY;
+ }
+```
+###### /seedu/gtd/storage/XmlAdaptedTask.java
+``` java
+ @XmlElement(required = true)
+ private String name;
+ @XmlElement(required = true)
+ private String startDate;
+ @XmlElement(required = true)
+ private String dueDate;
+ @XmlElement(required = true)
+ private String address;
+ @XmlElement(required = true)
+ private String priority;
+ @XmlElement(required = true)
+ private boolean isDone;
+
+ @XmlElement
+ private List tagged = new ArrayList<>();
+
+ /**
+ * No-arg constructor for JAXB use.
+ */
+ public XmlAdaptedTask() {}
+
+
+ /**
+ * Converts a given Task into this class for JAXB use.
+ *
+ * @param source future changes to this will not affect the created XmlAdaptedTask
+ */
+ public XmlAdaptedTask(ReadOnlyTask source) {
+ name = source.getName().fullName;
+ startDate = source.getStartDate().value;
+ dueDate = source.getDueDate().value;
+ address = source.getAddress().value;
+ priority = source.getPriority().value;
+ isDone = source.getisDone();
+ tagged = new ArrayList<>();
+ for (Tag tag : source.getTags()) {
+ tagged.add(new XmlAdaptedTag(tag));
+ }
+ }
+
+ /**
+ * Converts this jaxb-friendly adapted task object into the model's Task object.
+ *
+ * @throws IllegalValueException if there were any data constraints violated in the adapted task
+ */
+ public Task toModelType() throws IllegalValueException {
+ final List taskTags = new ArrayList<>();
+ for (XmlAdaptedTag tag : tagged) {
+ taskTags.add(tag.toModelType());
+ }
+ final Name name = new Name(this.name);
+ final DueDate startDate = new DueDate(this.startDate);
+ final DueDate dueDate = new DueDate(this.dueDate);
+ final Address address = new Address(this.address);
+ final Priority priority = new Priority(this.priority);
+ final boolean isDone = this.isDone;
+ System.out.println("printed isdone as: " + isDone);
+ final UniqueTagList tags = new UniqueTagList(taskTags);
+ return new Task(name, startDate, dueDate, address, priority, tags, isDone);
+ }
+}
+```
diff --git a/collated/main/A0139072H.md b/collated/main/A0139072H.md
new file mode 100644
index 000000000000..5dcc44da8f86
--- /dev/null
+++ b/collated/main/A0139072H.md
@@ -0,0 +1,127 @@
+# A0139072H
+###### /seedu/gtd/logic/commands/SetFilePathCommand.java
+``` java
+
+/**
+ * Sets the file path of the saved tasklist to a new file
+ **/
+public class SetFilePathCommand extends Command {
+
+ public static final String COMMAND_WORD = "setPath";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": sets the new file location. "
+ + "Parameters: nameofnewfile\n"
+ + "Example: " + COMMAND_WORD
+ + " internalFolder/name_of_new_file";
+
+ public static final String MESSAGE_SUCCESS = "New file location set to: %1$s";
+ public static final String MESSAGE_INVALID_LOC_TASK = "The file location is invalid!";
+
+ private final String newFilePath;
+
+ /**
+ * Convenience constructor using raw values.
+ *
+ * @throws IllegalValueException if any of the raw values are invalid
+ */
+ public SetFilePathCommand(String givenString)
+ throws IllegalValueException {
+ this.newFilePath = givenString.trim();
+ }
+
+ @Override
+ public CommandResult execute() {
+ assert model != null;
+ try{
+ model.setFilePathTask(newFilePath);
+ } catch (Exception e) {
+ return new CommandResult(MESSAGE_INVALID_LOC_TASK);
+ }
+ return new CommandResult(String.format(MESSAGE_SUCCESS, newFilePath));
+ }
+
+}
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the setFilePath command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareSetFilePath(String args) {
+ if(args.equals("")){
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, SetFilePathCommand.MESSAGE_USAGE));
+ }
+ final String filePath = args;
+ try {
+ return new SetFilePathCommand(filePath);
+ } catch (IllegalValueException e) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, SetFilePathCommand.MESSAGE_USAGE));
+ }
+ }
+
+}
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+//// application-wide operations
+ public void setFilePathTask(String newFilePath) throws IOException{
+ Config changedConfig;
+ String configFilePathUsed;
+
+ System.out.println("SetFilePathTask");
+
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+ //Save the config back to the file
+ ConfigUtil.saveConfig(changedConfig, configFilePathUsed);
+ StorageManager newSaveMgr = new StorageManager(
+ new XmlAddressBookStorage(newFilePath),
+ new JsonUserPrefsStorage(changedConfig.getUserPrefsFilePath())
+ );
+ //Save the addressBook to the new location
+ newSaveMgr.saveAddressBook(this);
+ };
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+ //application-wide operations
+ public void setFilePathTask(String newFilePath) throws IOException{
+ addressBook.setFilePathTask(newFilePath);
+ indicateAddressBookChanged();
+ //NEEDS TO SAVE TO NEW FILEPATH
+ };
+}
+```
+###### /seedu/gtd/ui/BrowserPanel.java
+``` java
+ public void loadPage(){
+ browser.getEngine().load("http://calendar.google.com");
+ }
+
+```
+###### /seedu/gtd/ui/MainWindow.java
+``` java
+ private static final String ICON = "/images/tary.png";
+
+```
+###### /seedu/gtd/ui/MainWindow.java
+``` java
+ /**
+ * Launches the calendar.
+ */
+ @FXML
+ private void handleCal() {
+ browserPanel.loadPage();
+ }
+
+```
+###### /seedu/gtd/ui/UiManager.java
+``` java
+ private static final String ICON_APPLICATION = "/images/tary.png";
+
+```
diff --git a/collated/main/A0139158X.md b/collated/main/A0139158X.md
new file mode 100644
index 000000000000..8bf72a2f66f3
--- /dev/null
+++ b/collated/main/A0139158X.md
@@ -0,0 +1,74 @@
+# A0139158X
+###### /seedu/gtd/logic/commands/HelpCommand.java
+``` java
+public class HelpCommand extends Command {
+
+ public static final String COMMAND_WORD = "help";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Shows program usage instructions.\n"
+ + "Parameters: COMMANDWORD\n"
+ + "Example: " + COMMAND_WORD + " add";
+
+ public static final String SHOWING_HELP_MESSAGE = "Opened help window.";
+
+ public final String argument;
+
+ public HelpCommand(String arg) {
+ this.argument=arg;
+ }
+
+ @Override
+ public CommandResult execute() {
+
+ switch (argument) {
+
+ case AddCommand.COMMAND_WORD:
+ return new CommandResult(AddCommand.MESSAGE_USAGE);
+
+ case SelectCommand.COMMAND_WORD:
+ return new CommandResult(SelectCommand.MESSAGE_USAGE);
+
+ case DeleteCommand.COMMAND_WORD:
+ return new CommandResult(DeleteCommand.MESSAGE_USAGE);
+
+ case ClearCommand.COMMAND_WORD:
+ return new CommandResult(ClearCommand.MESSAGE_USAGE);
+
+ case FindCommand.COMMAND_WORD:
+ return new CommandResult(FindCommand.MESSAGE_USAGE);
+
+ case ListCommand.COMMAND_WORD:
+ return new CommandResult(ListCommand.MESSAGE_USAGE);
+
+ case ExitCommand.COMMAND_WORD:
+ return new CommandResult(ExitCommand.MESSAGE_USAGE);
+
+ case HelpCommand.COMMAND_WORD:
+ EventsCenter.getInstance().post(new ShowHelpRequestEvent());
+ return new CommandResult(MESSAGE_USAGE+"/n"+SHOWING_HELP_MESSAGE);
+
+ default:
+ EventsCenter.getInstance().post(new ShowHelpRequestEvent());
+ return new CommandResult(MESSAGE_USAGE+"/n"+SHOWING_HELP_MESSAGE);
+ }
+ }
+}
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ private Command prepareHelp(String args) {
+ //if no argument
+ if (args.equals("")) {
+ args="help";
+ }
+
+ final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(args.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ final String commandWord = matcher.group("commandWord");
+ return new HelpCommand(commandWord);
+ }
+
+```
diff --git a/collated/main/A0146130W.md b/collated/main/A0146130W.md
new file mode 100644
index 000000000000..416c34bdd023
--- /dev/null
+++ b/collated/main/A0146130W.md
@@ -0,0 +1,384 @@
+# A0146130W
+###### /seedu/gtd/commons/exceptions/DataConversionException.java
+``` java
+ public DataConversionException(String cause) {
+ super(cause);
+ }
+}
+```
+###### /seedu/gtd/logic/commands/EditCommand.java
+``` java
+ /**
+ * Adds a task to the address book.
+ */
+ public class EditCommand extends Command {
+
+ public static final String COMMAND_WORD = "edit";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ":\n"
+ + "Edits the task identified by the index number used in the last task listing.\n\t"
+ + "Parameters: [INDEX] (must be a positive integer) prefix/[NEW DETAIL]\n\t"
+ + "Example: " + COMMAND_WORD
+ + " 1 p/3";
+
+ public static final String MESSAGE_EDIT_TASK_SUCCESS = "Task updated: %1$s";
+
+ private int targetIndex;
+ private Hashtable newDetails;
+
+ public EditCommand(int targetIndex, Hashtable newDetails) {
+ this.targetIndex = targetIndex;
+ this.newDetails = newDetails;
+ }
+
+
+ @Override
+ public CommandResult execute() {
+
+ UnmodifiableObservableList lastShownList = model.getFilteredTaskList();
+
+ if (lastShownList.size() < targetIndex) {
+ indicateAttemptToExecuteIncorrectCommand();
+ return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+ }
+
+ ReadOnlyTask toEdit = lastShownList.get(targetIndex);
+ Task taskToUpdate = new Task(toEdit);
+
+ assert model != null;
+ try {
+ Set detailTypes = newDetails.keySet();
+ for(String detailType : detailTypes) {
+ System.out.println("from edit command: " + detailType + " " + newDetails.get(detailType));
+ taskToUpdate = updateTask(taskToUpdate, detailType, newDetails.get(detailType));
+ model.editTask(targetIndex, taskToUpdate);
+ }
+ } catch (IllegalValueException ive) {
+ return new CommandResult(ive.getMessage());
+ } catch (TaskNotFoundException e) {
+ assert false : "The target task cannot be missing";
+ }
+ return new CommandResult(String.format(MESSAGE_EDIT_TASK_SUCCESS, taskToUpdate));
+ }
+
+ private Task updateTask(Task taskToUpdate, String detailType, String newDetail) throws IllegalValueException {
+ taskToUpdate.edit(detailType, newDetail);
+ return taskToUpdate;
+ }
+
+ }
+```
+###### /seedu/gtd/logic/commands/FindCommand.java
+``` java
+ private final String keywords;
+ private Set keywordSet;
+ private final String cmd;
+
+ public FindCommand(String keywords, Set keywordSet, String cmd) {
+ this.keywords = keywords;
+ this.keywordSet = keywordSet;
+ this.cmd = cmd;
+ }
+
+ private String getMessageForTaskListShownSummaryIfExactPhraseNotFound(int displaySize) {
+ String task_tasks = (displaySize == 1) ? "task" : "tasks";
+
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found. Listing " + displaySize + " " + task_tasks + " containing the keywords entered instead.";
+ return String.format(MESSAGE_IF_EXACT_PHRASE_NOT_FOUND);
+ }
+
+ private String getMessageForTaskListShownSummaryIfExactFieldNotFound(int displaySize) {
+ String task_tasks = (displaySize == 1) ? "task" : "tasks";
+
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found in the specified field type. Listing " + displaySize + " " + task_tasks + " containing the keywords entered instead.";
+ return String.format(MESSAGE_IF_EXACT_PHRASE_NOT_FOUND);
+ }
+
+
+```
+###### /seedu/gtd/logic/commands/UndoCommand.java
+``` java
+
+package seedu.gtd.logic.commands;
+
+/**
+ * Deletes a task identified using it's last displayed index from the address book.
+ */
+public class UndoCommand extends Command {
+
+ public static final String COMMAND_WORD = "undo";
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Un-does the most recent modification of the task list.";
+ public static final String MESSAGE_SUCCESS = "Undo change";
+ public static final String MESSAGE_UNDO_LIMIT_REACHED = "Undo limit reached!";
+
+ public UndoCommand() {}
+
+ @Override
+ public CommandResult execute() {
+ if(model.undoAddressBookChange()) return new CommandResult(MESSAGE_SUCCESS);
+ else return new CommandResult(MESSAGE_UNDO_LIMIT_REACHED);
+ }
+
+}
+```
+###### /seedu/gtd/logic/parser/DateNaturalLanguageProcessor.java
+``` java
+
+/**
+ * Uses natty API: http://natty.joestelmach.com to parse natural language into dates or string
+ */
+public class DateNaturalLanguageProcessor implements NaturalLanguageProcessor {
+
+ private static final com.joestelmach.natty.Parser parser = new com.joestelmach.natty.Parser();
+ private static final String DATE_FORMAT = "dd/MM/yyyy HH:mm";
+
+ @Override
+ public String formatString(String naturalLanguageDate) {
+ List dateGroups = parser.parse(naturalLanguageDate);
+ Date parsedDate;
+ try {
+ parsedDate = refineDateGroupList(dateGroups);
+ } catch (NaturalLanguageException e) {
+ return "";
+ }
+ return formatDateToString(parsedDate);
+ }
+
+```
+###### /seedu/gtd/logic/parser/DateNaturalLanguageProcessor.java
+``` java
+
+ /**
+ * Chooses the first date from a list of dates that Natty has parsed from the natural language string
+ * @throws NaturalLanguageException
+ * */
+ private Date refineDateGroupList(List groups) throws NaturalLanguageException {
+ if(groups.size() == 0) throw new NaturalLanguageException();
+ return groups.get(0).getDates().get(0);
+ }
+
+ private String formatDateToString(Date date) {
+ Format formatter = new SimpleDateFormat(DATE_FORMAT);
+ return formatter.format(date);
+ }
+}
+```
+###### /seedu/gtd/logic/parser/NaturalLanguageProcessor.java
+``` java
+
+package seedu.gtd.logic.parser;
+
+import java.util.Date;
+
+import seedu.gtd.commons.exceptions.DataConversionException;
+
+public interface NaturalLanguageProcessor {
+
+ /** Takes in a string written in natural language and formats it.*/
+ String formatString(String s);
+ Date getDate(String dueDateRaw);
+
+ public static class NaturalLanguageException extends DataConversionException {
+ protected NaturalLanguageException() {
+ super("Natural Language Processor was unable to convert input");
+ }
+ }
+}
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private String parseDueDate(String dueDateRaw) {
+ NaturalLanguageProcessor nlp = new DateNaturalLanguageProcessor();
+ return nlp.formatString(dueDateRaw);
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the edit task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareEdit(String args) {
+
+ Optional index = parseIndex(args, EDIT_DATA_ARGS_FORMAT);
+ final Matcher matcher = EDIT_DATA_ARGS_FORMAT.matcher(args.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, EditCommand.MESSAGE_USAGE));
+ }
+
+ final String[] splitNewDetails = matcher.group("newDetails").split("\\s+");
+ ArrayList combinedDetails = combineSameDetails(splitNewDetails);
+
+ Hashtable newDetailsSet = new Hashtable();
+
+ for (String detail : combinedDetails) {
+ String detailType = extractDetailType(detail);
+ String preparedNewDetail = prepareNewDetail(detailType, detail);
+ System.out.println("before adding to hashtable: " + detailType + " " + preparedNewDetail);
+ newDetailsSet.put(detailType, preparedNewDetail);
+ }
+
+ return new EditCommand(
+ index.get()-1,
+ newDetailsSet
+ );
+ }
+
+ private ArrayList combineSameDetails(String[] details) {
+ ArrayList alDetails = new ArrayList(Arrays.asList(details));
+ System.out.println(alDetails.toString());
+
+ String name = new String();
+ String address = new String();
+ String dueDate = new String();
+ String priority = new String();
+
+ int currentDetailType = 0;
+
+ if(alDetails.size() == 1) {
+ return alDetails;
+ }
+
+ for (String detail: alDetails) {
+ System.out.println("detail: " + detail);
+
+ if(extractDetailType(detail).equals("name")) {
+ System.out.println("current detail type: " + currentDetailType);
+ switch(currentDetailType) {
+ case 1: address = address + " " + detail; break;
+ case 2: dueDate = dueDate + " " + detail; break;
+ case 3: priority = priority + " " + detail; break;
+ default: {
+ if(name.isEmpty()) name = detail;
+ else name = name + " " + detail;
+ break;
+ }
+ }
+ }
+ else if(extractDetailType(detail).equals("address")) {
+ System.out.println("detected address " + detail);
+ address = detail;
+ currentDetailType = 1;
+ }
+ else if(extractDetailType(detail).equals("dueDate")) {
+ System.out.println("detected dueDate " + detail);
+ dueDate = detail;
+ currentDetailType = 2;
+ }
+ else if(extractDetailType(detail).equals("priority")) {
+ System.out.println("detected priority " + detail);
+ address = detail;
+ currentDetailType = 3;
+ }
+ }
+
+ ArrayList finalCombined = new ArrayList();
+ //does not remove the separate words from the list, they will be overwritten by the final combined string
+ if(!name.isEmpty()) finalCombined.add(name);
+ System.out.println("from combining name: " + name);
+ if(!address.isEmpty()) finalCombined.add(address);
+ System.out.println("from combining address: " + address);
+ if(!dueDate.isEmpty()) finalCombined.add(dueDate);
+ if(!priority.isEmpty()) finalCombined.add(priority);
+
+ System.out.println("from combining: " + finalCombined.toString());
+ return finalCombined;
+ }
+
+ private String removeDetailPrefix(String detailWithPrefix) {
+ return detailWithPrefix.substring(detailWithPrefix.indexOf('/') + 1);
+ }
+
+ private String prepareNewDetail(String detailType, String detailWithPrefix) {
+ String detail = removeDetailPrefix(detailWithPrefix);
+ if(detailType.equals("dueDate")) detail = parseDueDate(detail);
+ return detail;
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ private Optional parseIndex(String command, Pattern matcherFormat) {
+ final Matcher matcher = matcherFormat.matcher(command.trim());
+ if (!matcher.matches()) {
+ return Optional.empty();
+ }
+
+ String index = matcher.group("targetIndex");
+ if(!StringUtil.isUnsignedInteger(index)){
+ return Optional.empty();
+ }
+ return Optional.of(Integer.parseInt(index));
+
+ }
+
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+ /**
+ * Edits a task in the address book.
+ * Also checks the updated task's tags and updates {@link #tags} with any new tags found,
+ * and updates the Tag objects in the task to point to those in {@link #tags}.
+ *
+ * @throws UniqueTaskList.TaskNotFoundException if the task was not found.
+ */
+ public void editTask(int index, Task t) throws UniqueTaskList.TaskNotFoundException {
+ syncTagsWithMasterList(t);
+ tasks.edit(index, t);
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+ @Override
+ public synchronized void editTask(int targetIndex, Task task) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ addressBook.editTask(targetIndex, task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public void clearTaskList() {
+ savePreviousAddressBook();
+ resetData(AddressBook.getEmptyAddressBook());
+ }
+
+```
+###### /seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Edits an equivalent task from the list.
+ *
+ * @throws TaskNotFoundException if no such task could be found in the list.
+ */
+ public void edit(int targetIndex, Task toEdit) throws TaskNotFoundException {
+ assert toEdit != null;
+ if (invalidIndex(targetIndex)) {
+ throw new TaskNotFoundException();
+ }
+ internalList.set(targetIndex, toEdit);
+ }
+
+ public void done(int targetIndex, Task taskdone) throws TaskNotFoundException {
+ System.out.println("in uniquetasklist");
+ System.out.println(taskdone.getName() + " " + taskdone.getisDone());
+ System.out.println("index at final:" + targetIndex);
+ assert taskdone != null;
+ if (invalidIndex(targetIndex)) {
+ throw new TaskNotFoundException();
+ }
+ System.out.println("marked done in model");
+ internalList.set(targetIndex, taskdone);
+ }
+
+ private boolean invalidIndex(int i) {
+ if(i < 0 || i >= internalList.size()) return true;
+ return false;
+ }
+
+```
diff --git a/collated/main/A0146130Wreused.md b/collated/main/A0146130Wreused.md
new file mode 100644
index 000000000000..3772652dbc96
--- /dev/null
+++ b/collated/main/A0146130Wreused.md
@@ -0,0 +1,23 @@
+# A0146130Wreused
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ private String extractDetailType(String args) {
+ String preprocessedArgs = " " + appendEnd(args.trim());
+ final Matcher dueDateMatcher = DUEDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher addressMatcher = ADDRESS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher priorityMatcher = PRIORITY_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+
+ if(addressMatcher.matches()) {
+ return "address";
+ }
+ else if(dueDateMatcher.matches()) {
+ return "dueDate";
+ }
+ else if(priorityMatcher.matches()) {
+ return "priority";
+ }
+
+ return "name";
+ }
+
+```
diff --git a/collated/main/addressbooklevel4.md b/collated/main/addressbooklevel4.md
new file mode 100644
index 000000000000..d892729b659d
--- /dev/null
+++ b/collated/main/addressbooklevel4.md
@@ -0,0 +1,1081 @@
+# addressbooklevel4
+###### /seedu/gtd/logic/commands/AddCommand.java
+``` java
+ @Override
+ public CommandResult execute() {
+ assert model != null;
+ try {
+ model.addTask(toAdd);
+ return new CommandResult(String.format(MESSAGE_SUCCESS, toAdd));
+ } catch (UniqueTaskList.DuplicateTaskException e) {
+ return new CommandResult(MESSAGE_DUPLICATE_TASK);
+ }
+
+ }
+
+}
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ /**
+ * Used for initial separation of command word and args.
+ */
+ private static final Pattern BASIC_COMMAND_FORMAT = Pattern.compile("(?\\S+)(?.*)");
+
+ private static final Pattern TASK_INDEX_ARGS_FORMAT = Pattern.compile("(?.+)");
+
+ private static final Pattern KEYWORDS_ARGS_FORMAT =
+ Pattern.compile("(?\\S+(?:\\s+\\S+)*)"); // one or more keywords separated by whitespace
+
+// private static final Pattern TASK_DATA_ARGS_FORMAT = // '/' forward slashes are reserved for delimiter prefixes
+// Pattern.compile("(?[^/]+)"
+// + " d/(?[^/]+)"
+// + " a/(?[^/]+)"
+// + " p/(?[^/]+)"
+// + "(?(?: t/[^/]+)*)"); // variable number of tags
+
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private static final Pattern EDIT_DATA_ARGS_FORMAT =
+ Pattern.compile("(?\\S+)"
+ + " (?\\S+(?:\\s+\\S+)*)");
+
+ public Parser() {}
+
+ /**
+ * Parses user input into command for execution.
+ *
+ * @param userInput full user input string
+ * @return the command based on the user input
+ */
+ public Command parseCommand(String userInput) {
+ final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(userInput.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ final String commandWord = matcher.group("commandWord");
+ final String arguments = matcher.group("arguments");
+ switch (commandWord) {
+
+ case AddCommand.COMMAND_WORD:
+ return prepareAdd(arguments);
+
+ case EditCommand.COMMAND_WORD:
+ return prepareEdit(arguments);
+
+ case SelectCommand.COMMAND_WORD:
+ return prepareSelect(arguments);
+
+ case DeleteCommand.COMMAND_WORD:
+ return prepareDelete(arguments);
+
+ case DoneCommand.COMMAND_WORD:
+ return prepareDone(arguments);
+
+ case ClearCommand.COMMAND_WORD:
+ return new ClearCommand();
+
+ case FindCommand.COMMAND_WORD:
+ return prepareFind(arguments);
+
+ case ListCommand.COMMAND_WORD:
+ return prepareList(arguments);
+
+ case ExitCommand.COMMAND_WORD:
+ return new ExitCommand();
+
+ case HelpCommand.COMMAND_WORD:
+ return prepareHelp(arguments);
+
+
+ case UndoCommand.COMMAND_WORD:
+ return new UndoCommand();
+
+ case SetFilePathCommand.COMMAND_WORD:
+ return prepareSetFilePath(arguments);
+
+
+ default:
+ return new IncorrectCommand(MESSAGE_UNKNOWN_COMMAND);
+ }
+ }
+
+ /**
+ * Parses arguments in the context of the add task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Extracts the new task's tags from the add command's tag arguments string.
+ * Merges duplicate tag strings.
+ */
+ private static Set getTagsFromArgs(String tagArguments) {
+ // no tags
+ if (tagArguments.isEmpty()) {
+ return Collections.emptySet();
+ }
+
+ // replace first delimiter prefix, then split
+ final Collection tagStrings = Arrays.asList(tagArguments.split(" "));
+ return new HashSet<>(tagStrings);
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the delete task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareDelete(String args) {
+
+ Optional index = parseIndex(args);
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE));
+ }
+
+ return new DeleteCommand(index.get());
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+ /**
+ * Parses arguments in the context of the select task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareSelect(String args) {
+ Optional index = parseIndex(args);
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, SelectCommand.MESSAGE_USAGE));
+ }
+
+ return new SelectCommand(index.get());
+ }
+
+ /**
+ * Returns the specified index in the {@code command} IF a positive unsigned integer is given as the index.
+ * Returns an {@code Optional.empty()} otherwise.
+ */
+ private Optional parseIndex(String command) {
+ final Matcher matcher = TASK_INDEX_ARGS_FORMAT.matcher(command.trim());
+ if (!matcher.matches()) {
+ return Optional.empty();
+ }
+
+ String index = matcher.group("targetIndex");
+ if(!StringUtil.isUnsignedInteger(index)){
+ return Optional.empty();
+ }
+ return Optional.of(Integer.parseInt(index));
+
+ }
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the find task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+
+```
+###### /seedu/gtd/logic/parser/Parser.java
+``` java
+
+private Command prepareList(String args) {
+
+ // check if parameters are specified and pass specified field to FindCommand
+
+ //String preprocessedArgs = " " + appendEnd(args.trim());
+ return new ListCommand(args);
+}
+
+ /**
+ * Parses arguments in the context of the help command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+```
+###### /seedu/gtd/MainApp.java
+``` java
+public class MainApp extends Application {
+ private static final Logger logger = LogsCenter.getLogger(MainApp.class);
+
+ public static final Version VERSION = new Version(1, 0, 0, true);
+
+ protected Ui ui;
+ protected Logic logic;
+ protected Storage storage;
+ protected Model model;
+ protected Config config;
+ protected UserPrefs userPrefs;
+
+ public MainApp() {}
+
+ @Override
+ public void init() throws Exception {
+ logger.info("=============================[ Initializing TaskList ]===========================");
+ super.init();
+
+ config = initConfig(getApplicationParameter("config"));
+ storage = new StorageManager(config.getAddressBookFilePath(), config.getUserPrefsFilePath());
+
+ userPrefs = initPrefs(config);
+
+ initLogging(config);
+
+ model = initModelManager(storage, userPrefs);
+
+ logic = new LogicManager(model, storage);
+
+ ui = new UiManager(logic, config, userPrefs);
+
+ initEventsCenter();
+ }
+
+ private String getApplicationParameter(String parameterName){
+ Map applicationParameters = getParameters().getNamed();
+ return applicationParameters.get(parameterName);
+ }
+
+ private Model initModelManager(Storage storage, UserPrefs userPrefs) {
+ Optional addressBookOptional;
+ ReadOnlyAddressBook initialData;
+ try {
+ addressBookOptional = storage.readAddressBook();
+ if(!addressBookOptional.isPresent()){
+ logger.info("Data file not found. Will be starting with an empty TaskList");
+ }
+ initialData = addressBookOptional.orElse(new AddressBook());
+ } catch (DataConversionException e) {
+ logger.warning("Data file not in the correct format. Will be starting with an empty TaskList");
+ initialData = new AddressBook();
+ } catch (IOException e) {
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
+ initialData = new AddressBook();
+ }
+
+ return new ModelManager(initialData, userPrefs);
+ }
+
+ private void initLogging(Config config) {
+ LogsCenter.init(config);
+ }
+
+ protected Config initConfig(String configFilePath) {
+ Config initializedConfig;
+ String configFilePathUsed;
+
+ configFilePathUsed = Config.DEFAULT_CONFIG_FILE;
+
+ if(configFilePath != null) {
+ logger.info("Custom Config file specified " + configFilePath);
+ configFilePathUsed = configFilePath;
+ }
+
+ logger.info("Using config file : " + configFilePathUsed);
+
+ try {
+ Optional configOptional = ConfigUtil.readConfig(configFilePathUsed);
+ initializedConfig = configOptional.orElse(new Config());
+ } catch (DataConversionException e) {
+ logger.warning("Config file at " + configFilePathUsed + " is not in the correct format. " +
+ "Using default config properties");
+ initializedConfig = new Config();
+ }
+
+ //Update config file in case it was missing to begin with or there are new/unused fields
+ try {
+ ConfigUtil.saveConfig(initializedConfig, configFilePathUsed);
+ } catch (IOException e) {
+ logger.warning("Failed to save config file : " + StringUtil.getDetails(e));
+ }
+ return initializedConfig;
+ }
+
+ protected UserPrefs initPrefs(Config config) {
+ assert config != null;
+
+ String prefsFilePath = config.getUserPrefsFilePath();
+ logger.info("Using prefs file : " + prefsFilePath);
+
+ UserPrefs initializedPrefs;
+ try {
+ Optional prefsOptional = storage.readUserPrefs();
+ initializedPrefs = prefsOptional.orElse(new UserPrefs());
+ } catch (DataConversionException e) {
+ logger.warning("UserPrefs file at " + prefsFilePath + " is not in the correct format. " +
+ "Using default user prefs");
+ initializedPrefs = new UserPrefs();
+ } catch (IOException e) {
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
+ initializedPrefs = new UserPrefs();
+ }
+
+ //Update prefs file in case it was missing to begin with or there are new/unused fields
+ try {
+ storage.saveUserPrefs(initializedPrefs);
+ } catch (IOException e) {
+ logger.warning("Failed to save config file : " + StringUtil.getDetails(e));
+ }
+
+ return initializedPrefs;
+ }
+
+ private void initEventsCenter() {
+ EventsCenter.getInstance().registerHandler(this);
+ }
+
+ @Override
+ public void start(Stage primaryStage) {
+ logger.info("Starting TaskList " + MainApp.VERSION);
+ ui.start(primaryStage);
+ }
+
+ @Override
+ public void stop() {
+ logger.info("============================ [ Stopping Task List ] =============================");
+ ui.stop();
+ try {
+ storage.saveUserPrefs(userPrefs);
+ } catch (IOException e) {
+ logger.severe("Failed to save preferences " + StringUtil.getDetails(e));
+ }
+ Platform.exit();
+ System.exit(0);
+ }
+
+ @Subscribe
+ public void handleExitAppRequestEvent(ExitAppRequestEvent event) {
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ this.stop();
+ }
+
+ public static void main(String[] args) {
+ launch(args);
+ }
+}
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+ private final UniqueTaskList tasks;
+ private final UniqueTagList tags;
+
+ {
+ tasks = new UniqueTaskList();
+ tags = new UniqueTagList();
+ }
+
+ public AddressBook() {}
+
+ /**
+ * Tasks and Tags are copied into this addressbook
+ */
+ public AddressBook(ReadOnlyAddressBook toBeCopied) {
+ this(toBeCopied.getUniqueTaskList(), toBeCopied.getUniqueTagList());
+ }
+
+ /**
+ * Tasks and Tags are copied into this addressbook
+ */
+ public AddressBook(UniqueTaskList tasks, UniqueTagList tags) {
+ resetData(tasks.getInternalList(), tags.getInternalList());
+ }
+
+ public static ReadOnlyAddressBook getEmptyAddressBook() {
+ return new AddressBook();
+ }
+
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+ //Reused config saving
+ configFilePathUsed = Config.DEFAULT_CONFIG_FILE;
+ try {
+ Optional configOptional = ConfigUtil.readConfig(configFilePathUsed);
+ changedConfig = configOptional.orElse(new Config());
+ } catch (DataConversionException e) {
+ changedConfig = new Config();
+ }
+
+ changedConfig.setAddressBookFilePath(newFilePath);
+ System.out.println("Saved to " + newFilePath);
+
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+//// list overwrite operations
+
+ public ObservableList getTasks() {
+ return tasks.getInternalList();
+ }
+
+ public void setTasks(List tasks) {
+ this.tasks.getInternalList().setAll(tasks);
+ }
+
+ public void setTags(Collection tags) {
+ this.tags.getInternalList().setAll(tags);
+ }
+
+ public void resetData(Collection newTasks, Collection newTags) {
+ setTasks(newTasks.stream().map(Task::new).collect(Collectors.toList()));
+ setTags(newTags);
+ }
+
+ public void resetData(ReadOnlyAddressBook newData) {
+ resetData(newData.getTaskList(), newData.getTagList());
+ }
+
+//// task-level operations
+
+ /**
+ * Adds a task to the address book.
+ * Also checks the new task's tags and updates {@link #tags} with any new tags found,
+ * and updates the Tag objects in the task to point to those in {@link #tags}.
+ *
+ * @throws UniqueTaskList.DuplicateTaskException if an equivalent task already exists.
+ */
+ public void addTask(Task t) throws UniqueTaskList.DuplicateTaskException {
+ syncTagsWithMasterList(t);
+ tasks.add(t);
+ }
+
+```
+###### /seedu/gtd/model/AddressBook.java
+``` java
+ /**
+ * Ensures that every tag in this task:
+ * - exists in the master list {@link #tags}
+ * - points to a Tag object in the master list
+ */
+ private void syncTagsWithMasterList(Task t) {
+ final UniqueTagList taskTags = t.getTags();
+ tags.mergeFrom(taskTags);
+
+ // Create map with values = tag object references in the master list
+ final Map masterTagObjects = new HashMap<>();
+ for (Tag tag : tags) {
+ masterTagObjects.put(tag, tag);
+ }
+
+ // Rebuild the list of task tags using references from the master list
+ final Set commonTagReferences = new HashSet<>();
+ for (Tag tag : taskTags) {
+ commonTagReferences.add(masterTagObjects.get(tag));
+ }
+ t.setTags(new UniqueTagList(commonTagReferences));
+ }
+
+ public boolean removeTask(ReadOnlyTask key) throws UniqueTaskList.TaskNotFoundException {
+ if (tasks.remove(key)) {
+ return true;
+ } else {
+ throw new UniqueTaskList.TaskNotFoundException();
+ }
+ }
+
+ public void doneTask(int index, Task target) throws TaskNotFoundException {
+ tasks.done(index, target);
+ }
+
+//// tag-level operations
+
+ public void addTag(Tag t) throws UniqueTagList.DuplicateTagException {
+ tags.add(t);
+ }
+
+//// util methods
+
+ @Override
+ public String toString() {
+ return tasks.getInternalList().size() + " tasks, " + tags.getInternalList().size() + " tags";
+ // TODO: refine later
+ }
+
+ @Override
+ public List getTaskList() {
+ return Collections.unmodifiableList(tasks.getInternalList());
+ }
+
+ @Override
+ public List getTagList() {
+ return Collections.unmodifiableList(tags.getInternalList());
+ }
+
+ @Override
+ public UniqueTaskList getUniqueTaskList() {
+ return this.tasks;
+ }
+
+ @Override
+ public UniqueTagList getUniqueTagList() {
+ return this.tags;
+ }
+
+
+ @Override
+ public boolean equals(Object other) {
+ return other == this // short circuit if same object
+ || (other instanceof AddressBook // instanceof handles nulls
+ && this.tasks.equals(((AddressBook) other).tasks)
+ && this.tags.equals(((AddressBook) other).tags));
+ }
+
+ @Override
+ public int hashCode() {
+ // use this method for custom fields hashing instead of implementing your own
+ return Objects.hash(tasks, tags);
+ }
+}
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+
+ private static final Logger logger = LogsCenter.getLogger(ModelManager.class);
+
+ private AddressBook addressBook;
+ private final FilteredList filteredTasks;
+ private Stack previousAddressBook;
+
+ /**
+ * Initializes a ModelManager with the given AddressBook
+ * AddressBook and its variables should not be null
+ */
+ public ModelManager(AddressBook src, UserPrefs userPrefs) {
+ super();
+ assert src != null;
+ assert userPrefs != null;
+
+ logger.fine("Initializing with address book: " + src + " and user prefs " + userPrefs);
+
+ addressBook = new AddressBook(src);
+ filteredTasks = new FilteredList<>(addressBook.getTasks());
+ previousAddressBook = new Stack();
+ previousAddressBook.push(new AddressBook(addressBook));
+ }
+
+ public ModelManager() {
+ this(new AddressBook(), new UserPrefs());
+ }
+
+ public ModelManager(ReadOnlyAddressBook initialData, UserPrefs userPrefs) {
+ addressBook = new AddressBook(initialData);
+ filteredTasks = new FilteredList<>(addressBook.getTasks());
+ previousAddressBook = new Stack();
+ previousAddressBook.push(new AddressBook(addressBook));
+ }
+
+ private void resetData(ReadOnlyAddressBook newData) {
+ addressBook.resetData(newData);
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public ReadOnlyAddressBook getAddressBook() {
+ return addressBook;
+ }
+
+ /** Raises an event to indicate the model has changed */
+ private void indicateAddressBookChanged() {
+ raise(new AddressBookChangedEvent(addressBook));
+ }
+
+ private void savePreviousAddressBook() {
+ previousAddressBook.push(new AddressBook(addressBook));
+ }
+
+ @Override
+ public boolean undoAddressBookChange() {
+ if(previousAddressBook.isEmpty()) {
+ return false;
+ }
+ else{
+ resetData(previousAddressBook.pop());
+ return true;
+ }
+ }
+
+ @Override
+ public synchronized void deleteTask(ReadOnlyTask target) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ addressBook.removeTask(target);
+ indicateAddressBookChanged();
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+
+ @Override
+ public synchronized void addTask(Task task) throws UniqueTaskList.DuplicateTaskException {
+ savePreviousAddressBook();
+ addressBook.addTask(task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+ //=========== Filtered Task List Accessors ===============================================================
+
+ @Override
+ public UnmodifiableObservableList getFilteredTaskList() {
+ return new UnmodifiableObservableList<>(filteredTasks);
+ }
+
+```
+###### /seedu/gtd/model/ModelManager.java
+``` java
+ interface Expression {
+ boolean satisfies(ReadOnlyTask task);
+ String toString();
+ }
+
+ private class PredicateExpression implements Expression {
+
+ private final Qualifier qualifier;
+
+ PredicateExpression(Qualifier qualifier) {
+ this.qualifier = qualifier;
+ }
+
+ @Override
+ public boolean satisfies(ReadOnlyTask task) {
+ return qualifier.run(task);
+ }
+
+ @Override
+ public String toString() {
+ return qualifier.toString();
+ }
+ }
+
+ interface Qualifier {
+ boolean run(ReadOnlyTask task);
+ String toString();
+ }
+
+ private class NameQualifier implements Qualifier {
+ protected Set keywordSet;
+
+ NameQualifier(Set keywordSet) {
+ this.keywordSet = keywordSet;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ return keywordSet.stream()
+ .filter(keyword -> StringUtil.containsIgnoreCase(task.getName().fullName, keyword))
+ .findAny()
+ .isPresent();
+ }
+
+ @Override
+ public String toString() {
+ return "name=" + String.join(", ", keywordSet);
+ }
+ }
+
+```
+###### /seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Signals that an operation would have violated the 'no duplicates' property of the list.
+ */
+ public static class DuplicateTaskException extends DuplicateDataException {
+ protected DuplicateTaskException() {
+ super("Operation would result in duplicate tasks");
+ }
+ }
+
+ /**
+ * Signals that an operation targeting a specified task in the list would fail because
+ * there is no such matching task in the list.
+ */
+ public static class TaskNotFoundException extends Exception {}
+
+ private final ObservableList internalList = FXCollections.observableArrayList();
+
+ /**
+ * Constructs empty TaskList.
+ */
+ public UniqueTaskList() {}
+
+ /**
+ * Returns true if the list contains an equivalent task as the given argument.
+ */
+ public boolean contains(ReadOnlyTask toCheck) {
+ assert toCheck != null;
+ return internalList.contains(toCheck);
+ }
+
+ /**
+ * Adds a task to the list.
+ *
+ * @throws DuplicateTaskException if the task to add is a duplicate of an existing task in the list.
+ */
+ public void add(Task toAdd) throws DuplicateTaskException {
+ assert toAdd != null;
+ if (contains(toAdd)) {
+ throw new DuplicateTaskException();
+ }
+ internalList.add(toAdd);
+ }
+
+```
+###### /seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Removes the equivalent task from the list.
+ *
+ * @throws TaskNotFoundException if no such task could be found in the list.
+ */
+ public boolean remove(ReadOnlyTask toRemove) throws TaskNotFoundException {
+ assert toRemove != null;
+ final boolean taskFoundAndDeleted = internalList.remove(toRemove);
+ if (!taskFoundAndDeleted) {
+ throw new TaskNotFoundException();
+ }
+ return taskFoundAndDeleted;
+ }
+
+ public ObservableList getInternalList() {
+ return internalList;
+ }
+
+ @Override
+ public Iterator iterator() {
+ return internalList.iterator();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other == this // short circuit if same object
+ || (other instanceof UniqueTaskList // instanceof handles nulls
+ && this.internalList.equals(
+ ((UniqueTaskList) other).internalList));
+ }
+
+ @Override
+ public int hashCode() {
+ return internalList.hashCode();
+ }
+}
+```
+###### /seedu/gtd/ui/BrowserPanel.java
+``` java
+ /**
+ * Frees resources allocated to the browser.
+ */
+ public void freeResources() {
+ browser = null;
+ }
+
+}
+```
+###### /seedu/gtd/ui/MainWindow.java
+``` java
+ private static final String FXML = "MainWindow.fxml";
+ public static final int MIN_HEIGHT = 768;
+ public static final int MIN_WIDTH = 1024;
+
+ private Logic logic;
+
+ // Independent Ui parts residing in this Ui container
+ private BrowserPanel browserPanel;
+ private TaskListPanel taskListPanel;
+ private ResultDisplay resultDisplay;
+ private StatusBarFooter statusBarFooter;
+ private CommandBox commandBox;
+ private Config config;
+ private UserPrefs userPrefs;
+
+ // Handles to elements of this Ui container
+ private VBox rootLayout;
+ private Scene scene;
+
+ private String addressBookName;
+
+ @FXML
+ private AnchorPane browserPlaceholder;
+
+ @FXML
+ private AnchorPane commandBoxPlaceholder;
+
+ @FXML
+ private MenuItem helpMenuItem;
+
+ @FXML
+ private AnchorPane taskListPanelPlaceholder;
+
+ @FXML
+ private AnchorPane resultDisplayPlaceholder;
+
+ @FXML
+ private AnchorPane statusbarPlaceholder;
+
+
+ public MainWindow() {
+ super();
+ }
+
+ @Override
+ public void setNode(Node node) {
+ rootLayout = (VBox) node;
+ }
+
+ @Override
+ public String getFxmlPath() {
+ return FXML;
+ }
+
+ public static MainWindow load(Stage primaryStage, Config config, UserPrefs prefs, Logic logic) {
+
+ MainWindow mainWindow = UiPartLoader.loadUiPart(primaryStage, new MainWindow());
+ mainWindow.configure(config.getAppTitle(), config.getAddressBookName(), config, prefs, logic);
+ return mainWindow;
+ }
+
+ private void configure(String appTitle, String addressBookName, Config config, UserPrefs prefs,
+ Logic logic) {
+
+ //Set dependencies
+ this.logic = logic;
+ this.addressBookName = addressBookName;
+ this.config = config;
+ this.userPrefs = prefs;
+
+ //Configure the UI
+ setTitle(appTitle);
+ setIcon(ICON);
+ setWindowMinSize();
+ setWindowDefaultSize(prefs);
+ scene = new Scene(rootLayout);
+ primaryStage.setScene(scene);
+
+ setAccelerators();
+ }
+
+ private void setAccelerators() {
+ helpMenuItem.setAccelerator(KeyCombination.valueOf("F1"));
+ }
+
+ void fillInnerParts() {
+ browserPanel = BrowserPanel.load(getBrowserPlaceholder());
+ browserPanel.loadPage("https://calendar.google.com");
+ taskListPanel = TaskListPanel.load(primaryStage, getTaskListPlaceholder(), logic.getFilteredTaskList());
+ resultDisplay = ResultDisplay.load(primaryStage, getResultDisplayPlaceholder());
+ statusBarFooter = StatusBarFooter.load(primaryStage, getStatusbarPlaceholder(), config.getAddressBookFilePath());
+ commandBox = CommandBox.load(primaryStage, getCommandBoxPlaceholder(), resultDisplay, logic);
+ }
+
+ private AnchorPane getBrowserPlaceholder() {
+ return browserPlaceholder;
+ }
+
+ private AnchorPane getCommandBoxPlaceholder() {
+ return commandBoxPlaceholder;
+ }
+
+ private AnchorPane getStatusbarPlaceholder() {
+ return statusbarPlaceholder;
+ }
+
+ private AnchorPane getResultDisplayPlaceholder() {
+ return resultDisplayPlaceholder;
+ }
+
+ public AnchorPane getTaskListPlaceholder() {
+ return taskListPanelPlaceholder;
+ }
+
+ public void hide() {
+ primaryStage.hide();
+ }
+
+ private void setTitle(String appTitle) {
+ primaryStage.setTitle(appTitle);
+ }
+
+ /**
+ * Sets the default size based on user preferences.
+ */
+ protected void setWindowDefaultSize(UserPrefs prefs) {
+ primaryStage.setHeight(prefs.getGuiSettings().getWindowHeight());
+ primaryStage.setWidth(prefs.getGuiSettings().getWindowWidth());
+ if (prefs.getGuiSettings().getWindowCoordinates() != null) {
+ primaryStage.setX(prefs.getGuiSettings().getWindowCoordinates().getX());
+ primaryStage.setY(prefs.getGuiSettings().getWindowCoordinates().getY());
+ }
+ }
+
+ private void setWindowMinSize() {
+ primaryStage.setMinHeight(MIN_HEIGHT);
+ primaryStage.setMinWidth(MIN_WIDTH);
+ }
+
+ /**
+ * Returns the current size and the position of the main Window.
+ */
+ public GuiSettings getCurrentGuiSetting() {
+ return new GuiSettings(primaryStage.getWidth(), primaryStage.getHeight(),
+ (int) primaryStage.getX(), (int) primaryStage.getY());
+ }
+
+ @FXML
+ public void handleHelp() {
+ HelpWindow helpWindow = HelpWindow.load(primaryStage);
+ helpWindow.show();
+ }
+
+ public void show() {
+ primaryStage.show();
+ }
+
+ /**
+ * Closes the application.
+ */
+ @FXML
+ private void handleExit() {
+ raise(new ExitAppRequestEvent());
+ }
+
+```
+###### /seedu/gtd/ui/MainWindow.java
+``` java
+ public TaskListPanel getTaskListPanel() {
+ return this.taskListPanel;
+ }
+
+ public void loadTaskPage(ReadOnlyTask task) {
+ browserPanel.loadTaskPage(task);
+ }
+
+ public void releaseResources() {
+ browserPanel.freeResources();
+ }
+}
+```
+###### /seedu/gtd/ui/UiManager.java
+``` java
+ private Logic logic;
+ private Config config;
+ private UserPrefs prefs;
+ private MainWindow mainWindow;
+
+ public UiManager(Logic logic, Config config, UserPrefs prefs) {
+ super();
+ this.logic = logic;
+ this.config = config;
+ this.prefs = prefs;
+ }
+
+ @Override
+ public void start(Stage primaryStage) {
+ logger.info("Starting UI...");
+ primaryStage.setTitle(config.getAppTitle());
+
+ //Set the application icon.
+ primaryStage.getIcons().add(getImage(ICON_APPLICATION));
+
+ try {
+ mainWindow = MainWindow.load(primaryStage, config, prefs, logic);
+ mainWindow.show(); //This should be called before creating other UI parts
+ mainWindow.fillInnerParts();
+
+ } catch (Throwable e) {
+ logger.severe(StringUtil.getDetails(e));
+ showFatalErrorDialogAndShutdown("Fatal error during initializing", e);
+ }
+ }
+
+ @Override
+ public void stop() {
+ prefs.updateLastUsedGuiSetting(mainWindow.getCurrentGuiSetting());
+ mainWindow.hide();
+ mainWindow.releaseResources();
+ }
+
+ private void showFileOperationAlertAndWait(String description, String details, Throwable cause) {
+ final String content = details + ":\n" + cause.toString();
+ showAlertDialogAndWait(AlertType.ERROR, "File Op Error", description, content);
+ }
+
+ private Image getImage(String imagePath) {
+ return new Image(MainApp.class.getResourceAsStream(imagePath));
+ }
+
+ void showAlertDialogAndWait(Alert.AlertType type, String title, String headerText, String contentText) {
+ showAlertDialogAndWait(mainWindow.getPrimaryStage(), type, title, headerText, contentText);
+ }
+
+ private static void showAlertDialogAndWait(Stage owner, AlertType type, String title, String headerText,
+ String contentText) {
+ final Alert alert = new Alert(type);
+ alert.getDialogPane().getStylesheets().add("view/DarkTheme.css");
+ alert.initOwner(owner);
+ alert.setTitle(title);
+ alert.setHeaderText(headerText);
+ alert.setContentText(contentText);
+
+ alert.showAndWait();
+ }
+
+ private void showFatalErrorDialogAndShutdown(String title, Throwable e) {
+ logger.severe(title + " " + e.getMessage() + StringUtil.getDetails(e));
+ showAlertDialogAndWait(Alert.AlertType.ERROR, title, e.getMessage(), e.toString());
+ Platform.exit();
+ System.exit(1);
+ }
+
+ //==================== Event Handling Code =================================================================
+
+ @Subscribe
+ private void handleDataSavingExceptionEvent(DataSavingExceptionEvent event) {
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ showFileOperationAlertAndWait("Could not save data", "Could not save data to file", event.exception);
+ }
+
+ @Subscribe
+ private void handleShowHelpEvent(ShowHelpRequestEvent event) {
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ mainWindow.handleHelp();
+ }
+
+ @Subscribe
+ private void handleJumpToListRequestEvent(JumpToListRequestEvent event) {
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ mainWindow.getTaskListPanel().scrollTo(event.targetIndex);
+ }
+
+ @Subscribe
+ private void handleTaskPanelSelectionChangedEvent(TaskPanelSelectionChangedEvent event){
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ mainWindow.loadTaskPage(event.getNewSelection());
+ }
+
+}
+```
diff --git a/collated/test/A0130677A.md b/collated/test/A0130677A.md
new file mode 100644
index 000000000000..125503e54835
--- /dev/null
+++ b/collated/test/A0130677A.md
@@ -0,0 +1,262 @@
+# A0130677A
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ @Test
+ public void execute_add_invalidStartEndDate() throws Exception {
+ assertCommandBehavior(
+ "add complete tutorial s/tomorrow d/yesterday a/valid, address p/1", START_END_DATE_INVALID_COMMAND_FORMAT);
+ }
+
+ @Test
+ public void execute_add_floatingTask() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.floatingTask();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(toBeAdded);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateAddFloatingTask(toBeAdded),
+ String.format(AddCommand.MESSAGE_SUCCESS, toBeAdded),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+ @Test
+ public void execute_add_flexibleTaskData() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.fullTask();
+ Task dateChanged = helper.fullTaskChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(dateChanged);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateAddCommandInRandomOrder(toBeAdded),
+ String.format(AddCommand.MESSAGE_SUCCESS, dateChanged),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+ @Test
+ public void execute_add_optional_successful() throws Exception {
+
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task intendedResult = helper.optionalAddressDateChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(intendedResult);
+ String optionalAddressCmd = "add clean room d/noon p/3 t/tag1";
+
+ assertCommandBehavior(optionalAddressCmd,
+ String.format(AddCommand.MESSAGE_SUCCESS, intendedResult),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ @Test
+ public void execute_done_task() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task taskDone = helper.fullTaskDone();
+ List expectedTasks = helper.generateTaskList(taskDone);
+ AddressBook expectedAB = helper.generateAddressBook(expectedTasks);
+ model.addTask(taskDone);
+
+ // execute command and verify result
+ assertCommandBehavior("done 1",
+ String.format(DoneCommand.MESSAGE_DONE_TASK_SUCCESS, taskDone),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+// @Test
+// public void execute_list_done_showsDoneTasks() throws Exception {
+// // prepare expectations
+// TestDataHelper helper = new TestDataHelper();
+// Task toBeDone = helper.fullTask();
+// Task taskDone = helper.fullTaskDone();
+// List expectedTasks = helper.generateTaskList(taskDone);
+// AddressBook expectedAB = helper.generateAddressBook(expectedTasks);
+// List expectedList = expectedAB.getTaskList();
+//
+// // prepare address book state
+// model.addTask(taskDone);
+//
+// assertCommandBehavior("list done",
+// ListCommand.MESSAGE_SUCCESS_LIST_DONE,
+// expectedAB,
+// expectedList);
+// }
+//
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ @Test
+ public void execute_find_by_attributes() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task pTarget = helper.fullTask();
+ Task p = helper.floatingTask();
+
+ List twoTasks = helper.generateTaskList(pTarget, p);
+ AddressBook expectedAB = helper.generateAddressBook(twoTasks);
+ List expectedList = helper.generateTaskList(pTarget);
+ helper.addToModel(model, twoTasks);
+
+ assertCommandBehavior("find p/4",
+ Command.getMessageForTaskListShownSummary(expectedList.size()),
+ expectedAB,
+ expectedList);
+ }
+
+
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ /**
+ * A utility class to generate test data.
+ */
+ class TestDataHelper{
+
+ Task fullTask() throws Exception {
+ Name name = new Name("Pick up laundry");
+ DueDate startDate = new DueDate("morning");
+ DueDate privateDueDate = new DueDate("noon");
+ Address address = new Address("111, alpha street");
+ Priority privatePriority = new Priority("4");
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, startDate, privateDueDate, address, privatePriority, tags);
+ }
+
+ Task fullTaskChanged() throws Exception {
+ NaturalLanguageProcessor nlpTest = new DateNaturalLanguageProcessor();
+ String formattedDate = nlpTest.formatString("noon");
+ String formattedStartDate = nlpTest.formatString("morning");
+ Name name = new Name("Pick up laundry");
+ DueDate startDate = new DueDate(formattedStartDate);
+ DueDate privateDueDate = new DueDate(formattedDate);
+ Address address = new Address("111, alpha street");
+ Priority privatePriority = new Priority("4");
+ boolean isDone = false;
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, startDate, privateDueDate, address, privatePriority, tags, isDone);
+ }
+
+ Task fullTaskDone() throws Exception {
+ NaturalLanguageProcessor nlpTest = new DateNaturalLanguageProcessor();
+ String formattedDate = nlpTest.formatString("noon");
+ String formattedStartDate = nlpTest.formatString("morning");
+ Name name = new Name("Pick up laundry");
+ DueDate startDate = new DueDate(formattedStartDate);
+ DueDate privateDueDate = new DueDate(formattedDate);
+ Address address = new Address("111, alpha street");
+ Priority privatePriority = new Priority("4");
+ boolean isDone = true;
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, startDate, privateDueDate, address, privatePriority, tags, isDone);
+ }
+
+ Task floatingTask() throws Exception {
+ Name name = new Name("Pick up laundry");
+ DueDate startDate = new DueDate("nil");
+ DueDate privateDueDate = new DueDate("nil");
+ Address address = new Address("nil");
+ Priority privatePriority = new Priority("1");
+ UniqueTagList tags = new UniqueTagList();
+ return new Task(name, startDate, privateDueDate, address, privatePriority, tags);
+ }
+
+ Task optionalAddressDateChanged() throws Exception {
+ NaturalLanguageProcessor nlpTest = new DateNaturalLanguageProcessor();
+ String formattedDate = nlpTest.formatString("noon");
+ String formattedStartDate = nlpTest.formatString("morning");
+ Name name = new Name("clean room");
+ DueDate startDate = new DueDate(formattedStartDate);
+ DueDate privateDueDate = new DueDate(formattedDate);
+ Address address = new Address("none");
+ Priority privatePriority = new Priority("3");
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, startDate, privateDueDate, address, privatePriority, tags);
+ }
+
+ /**
+ * Generates a valid task using the given seed.
+ * Running this function with the same parameter values guarantees the returned task will have the same state.
+ * Each unique seed will generate a unique Task object.
+ *
+ * @param seed used to generate the task data field values
+ */
+ Task generateTask(int seed) throws Exception {
+ return new Task(
+ new Name("Task " + seed),
+ new DueDate("" + Math.abs(seed)),
+ new DueDate("" + Math.abs(seed)),
+ new Address(seed + ", -address"),
+ new Priority("1 "),
+ new UniqueTagList(new Tag("tag" + Math.abs(seed)), new Tag("tag" + Math.abs(seed + 1)))
+ );
+ }
+
+ /** Generates the correct add command based on the task given */
+ String generateAddCommand(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("add ");
+
+ cmd.append(p.getName().toString());
+ cmd.append(" s/").append(p.getStartDate());
+ cmd.append(" d/").append(p.getDueDate());
+ cmd.append(" a/").append(p.getAddress());
+ cmd.append(" p/").append(p.getPriority());
+
+ UniqueTagList tags = p.getTags();
+ for(Tag t: tags){
+ cmd.append(" t/").append(t.tagName);
+ }
+
+ return cmd.toString();
+ }
+
+ String generateAddCommandInRandomOrder(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("add ");
+
+ cmd.append(p.getName().toString());
+ cmd.append(" p/").append(p.getPriority());
+ cmd.append(" a/").append(p.getAddress());
+ cmd.append(" s/").append(p.getStartDate());
+ cmd.append(" d/").append(p.getDueDate());
+
+ UniqueTagList tags = p.getTags();
+ for(Tag t: tags){
+ cmd.append(" t/").append(t.tagName);
+ }
+
+ return cmd.toString();
+ }
+
+ String generateAddFloatingTask(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("add ");
+ cmd.append(p.getName().toString());
+ return cmd.toString();
+ }
+
+```
diff --git a/collated/test/A0146130W.md b/collated/test/A0146130W.md
new file mode 100644
index 000000000000..c49d2f786985
--- /dev/null
+++ b/collated/test/A0146130W.md
@@ -0,0 +1,264 @@
+# A0146130W
+###### /guitests/EditCommandTest.java
+``` java
+
+package guitests;
+
+import org.junit.Test;
+
+import seedu.gtd.testutil.TestTask;
+import seedu.gtd.testutil.TestUtil;
+
+import static org.junit.Assert.assertTrue;
+import static seedu.gtd.logic.commands.EditCommand.MESSAGE_EDIT_TASK_SUCCESS;
+
+public class EditCommandTest extends AddressBookGuiTest {
+
+ @Test
+ public void edit() {
+
+ //edit the priority of the first task
+ TestTask[] currentList = td.getTypicalTasks();
+ int targetIndex = 1;
+ String change = "p/4";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the dueDate of the last in the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ targetIndex = currentList.length;
+ change = "d/2";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the name task from the middle of the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ targetIndex = currentList.length/2;
+ change = "Cook lunch for friends";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the address task from the middle of the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ change = "a/Little India";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ /*
+ //edit everything at once
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ change = "Cook friends for lunch d/midnight a/SMU p/5";
+ String change1 = "Cook friends for lunch";
+ String change2 = "d/midnight";
+ String change3 = "a/SMU";
+ String change4 = "p/5";
+ String[] changes = {change1, change2, change3, change4};
+ assertMultipleEditSuccess(targetIndex, change, currentList, changes);
+ */
+
+ //invalid index
+ commandBox.runCommand("edit " + currentList.length + 1 + " Invalid");
+ assertResultMessage("The task index provided is invalid");
+
+ }
+
+ /**
+ * Runs the edit command to edit the task at specified index and confirms the result is correct.
+ * @param targetIndexOneIndexed e.g. to edit the first task in the list, 1 should be given as the target index.
+ * @param currentList A copy of the current list of tasks (before editing)
+ * @param change: contains detail with appropriate prefix that the user wants to edit into a task with index targetIndexOneIndexed.
+ *
+ */
+ private void assertEditSuccess(int targetIndexOneIndexed, String change, final TestTask[] currentList) {
+ TestTask taskToEdit = currentList[targetIndexOneIndexed-1]; //-1 because array uses zero indexing
+ TestTask[] expectedRemainder = TestUtil.editTaskInList(currentList, targetIndexOneIndexed, change, taskToEdit);
+ commandBox.runCommand("edit " + targetIndexOneIndexed + " " + change);
+
+ assertTrue(taskListPanel.isListMatching(expectedRemainder));
+
+ //confirm the result message is correct
+ assertResultMessage(String.format(MESSAGE_EDIT_TASK_SUCCESS, expectedRemainder[targetIndexOneIndexed-1]));
+ }
+
+ /*
+ private void assertMultipleEditSuccess(int targetIndexOneIndexed, String change, TestTask[] currentList, String[] changeArr) {
+ TestTask taskToEdit = currentList[targetIndexOneIndexed-1]; //-1 because array uses zero indexing
+
+ for(String c: changeArr) {
+ currentList = TestUtil.editTaskInList(currentList, targetIndexOneIndexed, c, taskToEdit);
+ }
+ TestTask[] expectedRemainder = currentList;
+
+ commandBox.runCommand("edit " + targetIndexOneIndexed + " " + change);
+
+ assertTrue(taskListPanel.isListMatching(expectedRemainder));
+
+ //confirm the result message is correct
+ assertResultMessage(String.format(MESSAGE_EDIT_TASK_SUCCESS, expectedRemainder[targetIndexOneIndexed-1]));
+ }
+ */
+}
+```
+###### /guitests/UndoCommandTest.java
+``` java
+
+package guitests;
+
+import org.junit.Test;
+
+import seedu.gtd.testutil.TestTask;
+
+import static org.junit.Assert.assertTrue;
+import static seedu.gtd.logic.commands.UndoCommand.MESSAGE_SUCCESS;
+import static seedu.gtd.logic.commands.UndoCommand.MESSAGE_UNDO_LIMIT_REACHED;
+
+import java.util.Stack;;
+
+public class UndoCommandTest extends AddressBookGuiTest {
+
+ @Test
+ public void undo() {
+
+ //undo the addition of the first task
+ TestTask[] currentList = td.getTypicalTasks();
+ Stack previousList = new Stack();
+ previousList.push(currentList);
+ commandBox.runCommand(td.george.getAddCommand());
+ assertUndoSuccess(previousList.pop());
+
+ //undo editing the dueDate of the last task in the list
+ int targetIndex = currentList.length;
+ String change = "d/2";
+ previousList.push(currentList);
+ commandBox.runCommand("edit " + targetIndex + " " + change);
+ assertUndoSuccess(previousList.pop());
+
+ //undo deleting a task from the middle of the list
+ targetIndex = currentList.length/2;
+ previousList.push(currentList);
+ commandBox.runCommand("delete " + targetIndex);
+ assertUndoSuccess(previousList.pop());
+
+ //undo clearing list
+ previousList.push(currentList);
+ commandBox.runCommand("clear");
+ assertUndoSuccess(previousList.pop());
+
+ //undo marking the middle task as done
+ previousList.push(currentList);
+ commandBox.runCommand("done " + targetIndex);
+ assertUndoSuccess(previousList.pop());
+
+ /*
+ //undo multiple times
+ previousList.push(currentList);
+ commandBox.runCommand("edit " + targetIndex + " " + change);
+ previousList.push(currentList);
+ commandBox.runCommand(td.george.getAddCommand());
+ previousList.push(currentList);
+ commandBox.runCommand("delete " + targetIndex);
+ previousList.push(currentList);
+ commandBox.runCommand("done " + targetIndex);
+ previousList.push(currentList);
+ commandBox.runCommand("clear");
+ assertMultipleUndoSuccess(previousList);
+ */
+ }
+
+ /**
+ * Runs the undo command to undo the last change to the task list
+ */
+ private void assertUndoSuccess(final TestTask[] previousList) {
+ commandBox.runCommand("undo");
+
+ //confirm the list now contains all previous tasks except the deleted task
+ assertTrue(taskListPanel.isListMatching(previousList));
+
+ //confirm the result message is correct
+ assertResultMessage(String.format(MESSAGE_SUCCESS));
+ }
+
+ private void assertMultipleUndoSuccess(final Stack previousList) {
+
+ //run undo multiple times and verify list each time
+ for(int i=1; i < previousList.size(); i++) {
+ commandBox.runCommand("undo");
+ assertTrue(taskListPanel.isListMatching(previousList.pop()));
+ assertResultMessage(String.format(MESSAGE_SUCCESS));
+ }
+
+ //verify that the undo limit message is shown when undo limit is reached
+ commandBox.runCommand("undo");
+ assertResultMessage(String.format(MESSAGE_UNDO_LIMIT_REACHED));
+ }
+
+}
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ /** Generates the correct add command based on the task given */
+ String generateEditCommand(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("edit ");
+ cmd.append(" d/").append(p.getDueDate());
+
+ return cmd.toString();
+ }
+```
+###### /seedu/gtd/testutil/TestUtil.java
+``` java
+
+ /**
+ * Edits a task in the array of tasks.
+ * @param tasks A array of tasks.
+ * @param tasksToAdd The tasks that are to be appended behind the original array.
+ * @return The modified array of tasks.
+ * @throws IllegalValueException
+ */
+ public static TestTask[] editTaskInList(final TestTask[] tasks, int index, String change, TestTask taskToEdit) {
+ List listOfTasks = asList(tasks);
+ TestTask taskEditted;
+ try {
+ taskEditted = TestUtilParser.editTask(taskToEdit, change);
+ } catch (IllegalValueException e) {
+ taskEditted = taskToEdit;
+ e.printStackTrace();
+ }
+ listOfTasks.set(index-1, taskEditted);
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+```
+###### /seedu/gtd/testutil/TestUtilParser.java
+``` java
+
+package seedu.gtd.testutil;
+
+import seedu.gtd.commons.exceptions.IllegalValueException;
+import seedu.gtd.logic.parser.DateNaturalLanguageProcessor;
+import seedu.gtd.logic.parser.NaturalLanguageProcessor;
+import seedu.gtd.model.task.Address;
+import seedu.gtd.model.task.DueDate;
+import seedu.gtd.model.task.Name;
+import seedu.gtd.model.task.Priority;
+
+/**
+ * A utility class that parses tasks for test cases.
+ */
+public class TestUtilParser {
+
+ public static TestTask editTask(TestTask task, String change) throws IllegalValueException {
+
+ TestTask newTask = task;
+ String changeWithoutPrefix = removeDetailPrefix(change);
+ String changePrefix = change.substring(0, 2);
+ System.out.println("From TestUtil Parser: " + changePrefix + " " + changeWithoutPrefix);
+
+ switch(change.substring(0, 2)) {
+ case "d/": newTask = new TestTask(task.getName(), task.getStartDate(), new DueDate(parseDueDate(changeWithoutPrefix)), task.getAddress(), task.getPriority(), task.getTags()); break;
+ case "a/": newTask = new TestTask(task.getName(), task.getStartDate(), task.getDueDate(), new Address(changeWithoutPrefix), task.getPriority(), task.getTags()); break;
+ case "p/": newTask = new TestTask(task.getName(), task.getStartDate(), task.getDueDate(), task.getAddress(), new Priority(changeWithoutPrefix), task.getTags()); break;
+ default: newTask = new TestTask(new Name(change), task.getStartDate(), task.getDueDate(), task.getAddress(), task.getPriority(), task.getTags());
+ }
+ return newTask;
+ }
+
+```
diff --git a/collated/test/A0146130Wreused.md b/collated/test/A0146130Wreused.md
new file mode 100644
index 000000000000..37a931aaa267
--- /dev/null
+++ b/collated/test/A0146130Wreused.md
@@ -0,0 +1,29 @@
+# A0146130Wreused
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+ @Test
+ public void execute_help() throws Exception {
+ assertCommandBehavior("help", HelpCommand.MESSAGE_USAGE+"/n"+HelpCommand.SHOWING_HELP_MESSAGE);
+ assertTrue(helpShown);
+ assertCommandBehavior("help add", AddCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help select", SelectCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help delete", DeleteCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help clear", ClearCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help find", FindCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help list", ListCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help exit", ExitCommand.MESSAGE_USAGE);
+ }
+
+```
+###### /seedu/gtd/testutil/TestUtilParser.java
+``` java
+ public static String parseDueDate(String dueDateRaw) {
+ NaturalLanguageProcessor nlp = new DateNaturalLanguageProcessor();
+ return nlp.formatString(dueDateRaw);
+ }
+
+ private static String removeDetailPrefix(String detailWithPrefix) {
+ return detailWithPrefix.substring(detailWithPrefix.indexOf('/') + 1);
+ }
+}
+```
diff --git a/collated/test/addressbooklevel4.md b/collated/test/addressbooklevel4.md
new file mode 100644
index 000000000000..81137e5e1074
--- /dev/null
+++ b/collated/test/addressbooklevel4.md
@@ -0,0 +1,544 @@
+# addressbooklevel4
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ /**
+ * See https://github.com/junit-team/junit4/wiki/rules#temporaryfolder-rule
+ */
+ @Rule
+ public TemporaryFolder saveFolder = new TemporaryFolder();
+
+ private Model model;
+ private Logic logic;
+
+ //These are for checking the correctness of the events raised
+ private ReadOnlyAddressBook latestSavedAddressBook;
+ private boolean helpShown;
+ private int targetedJumpIndex;
+
+ @Subscribe
+ private void handleLocalModelChangedEvent(AddressBookChangedEvent abce) {
+ latestSavedAddressBook = new AddressBook(abce.data);
+ }
+
+ @Subscribe
+ private void handleShowHelpRequestEvent(ShowHelpRequestEvent she) {
+ helpShown = true;
+ }
+
+ @Subscribe
+ private void handleJumpToListRequestEvent(JumpToListRequestEvent je) {
+ targetedJumpIndex = je.targetIndex;
+ }
+
+ @Before
+ public void setup() {
+ model = new ModelManager();
+ String tempAddressBookFile = saveFolder.getRoot().getPath() + "TempAddressBook.xml";
+ String tempPreferencesFile = saveFolder.getRoot().getPath() + "TempPreferences.json";
+ logic = new LogicManager(model, new StorageManager(tempAddressBookFile, tempPreferencesFile));
+ EventsCenter.getInstance().registerHandler(this);
+
+ latestSavedAddressBook = new AddressBook(model.getAddressBook()); // last saved assumed to be up to date before.
+ helpShown = false;
+ targetedJumpIndex = -1; // non yet
+ }
+
+ @After
+ public void teardown() {
+ EventsCenter.clearSubscribers();
+ }
+
+ @Test
+ public void execute_invalid() throws Exception {
+ String invalidCommand = " ";
+ assertCommandBehavior(invalidCommand,
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ /**
+ * Executes the command and confirms that the result message is correct.
+ * Both the 'address book' and the 'last shown list' are expected to be empty.
+ * @see #assertCommandBehavior(String, String, ReadOnlyAddressBook, List)
+ */
+ private void assertCommandBehavior(String inputCommand, String expectedMessage) throws Exception {
+ assertCommandBehavior(inputCommand, expectedMessage, new AddressBook(), Collections.emptyList());
+ }
+
+ /**
+ * Executes the command and confirms that the result message is correct and
+ * also confirms that the following three parts of the LogicManager object's state are as expected:
+ * - the internal address book data are same as those in the {@code expectedAddressBook}
+ * - the backing list shown by UI matches the {@code shownList}
+ * - {@code expectedAddressBook} was saved to the storage file.
+ */
+ private void assertCommandBehavior(String inputCommand, String expectedMessage,
+ ReadOnlyAddressBook expectedAddressBook,
+ List expectedShownList) throws Exception {
+
+ //Execute the command
+ CommandResult result = logic.execute(inputCommand);
+ System.out.println(inputCommand);
+
+ //Confirm the ui display elements should contain the right data
+ System.out.println(result.feedbackToUser);
+ System.out.println(expectedMessage);
+ assertEquals(expectedMessage, result.feedbackToUser);
+ System.out.println("correct message");
+ assertEquals(expectedShownList, model.getFilteredTaskList());
+ System.out.println("correct data in UI");
+
+ //Confirm the state of data (saved and in-memory) is as expected
+ assertEquals(expectedAddressBook, model.getAddressBook());
+ assertEquals(expectedAddressBook, latestSavedAddressBook);
+ }
+
+
+ @Test
+ public void execute_unknownCommandWord() throws Exception {
+ String unknownCommand = "uicfhmowqewca";
+ assertCommandBehavior(unknownCommand, MESSAGE_UNKNOWN_COMMAND);
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+ @Test
+ public void execute_exit() throws Exception {
+ assertCommandBehavior("exit", ExitCommand.MESSAGE_EXIT_ACKNOWLEDGEMENT);
+ }
+
+ @Test
+ public void execute_clear() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ model.addTask(helper.generateTask(1));
+ model.addTask(helper.generateTask(2));
+ model.addTask(helper.generateTask(3));
+
+ assertCommandBehavior("clear", ClearCommand.MESSAGE_SUCCESS, new AddressBook(), Collections.emptyList());
+ }
+
+ @Test
+ public void execute_add_invalidArgsFormat() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE);
+ assertCommandBehavior(
+ "add ", expectedMessage);
+ }
+
+
+ @Test
+ public void execute_add_invalidTaskData() throws Exception {
+ assertCommandBehavior(
+ "add []\\[;] d/12345 a/valid, address p/1", Name.MESSAGE_NAME_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/not_numbers a/valid, address p/2", DueDate.MESSAGE_DUEDATE_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/12345 a/valid, address p/not_priority_numbers", Priority.MESSAGE_PRIORITY_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/12345 a/valid, address p/5 t/invalid_-[.tag", Tag.MESSAGE_TAG_CONSTRAINTS);
+
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ @Test
+ public void execute_add_successful() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.fullTask();
+ Task dateChanged = helper.fullTaskChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(dateChanged);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateAddCommand(toBeAdded),
+ String.format(AddCommand.MESSAGE_SUCCESS, dateChanged),
+ expectedAB,
+ expectedAB.getTaskList());
+
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ @Test
+ public void execute_addDuplicate_notAllowed() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.fullTask();
+ Task changedDate = helper.fullTaskChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(changedDate);
+
+ // setup starting state
+ model.addTask(changedDate); // task already in internal address book
+
+ // execute command and verify result
+ assertCommandBehavior(
+ helper.generateAddCommand(toBeAdded),
+ AddCommand.MESSAGE_DUPLICATE_TASK,
+ expectedAB,
+ expectedAB.getTaskList());
+
+ }
+
+ /*
+ @Test
+ public void execute_edit_successful() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeEdited = helper.adam();
+ AddressBook expectedAB = helper.generateAddressBook(2);
+ expectedAB.editTask(1, toBeEdited);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateEditCommand(toBeEdited),
+ String.format(EditCommand.MESSAGE_EDIT_TASK_SUCCESS, toBeEdited),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+ */
+
+
+ @Test
+ public void execute_list_showsAllTasks() throws Exception {
+ // prepare expectations
+ TestDataHelper helper = new TestDataHelper();
+ AddressBook expectedAB = helper.generateAddressBook(2);
+ List expectedList = expectedAB.getTaskList();
+
+ // prepare address book state
+ helper.addToModel(model, 2);
+
+ assertCommandBehavior("list",
+ ListCommand.MESSAGE_SUCCESS_LIST,
+ expectedAB,
+ expectedList);
+ }
+
+```
+###### /seedu/gtd/testutil/TestUtil.java
+``` java
+
+ public static String LS = System.lineSeparator();
+
+ public static void assertThrows(Class expected, Runnable executable) {
+ try {
+ executable.run();
+ }
+ catch (Throwable actualException) {
+ if (!actualException.getClass().isAssignableFrom(expected)) {
+ String message = String.format("Expected thrown: %s, actual: %s", expected.getName(),
+ actualException.getClass().getName());
+ throw new AssertionFailedError(message);
+ } else return;
+ }
+ throw new AssertionFailedError(
+ String.format("Expected %s to be thrown, but nothing was thrown.", expected.getName()));
+ }
+
+ /**
+ * Folder used for temp files created during testing. Ignored by Git.
+ */
+ public static String SANDBOX_FOLDER = FileUtil.getPath("./src/test/data/sandbox/");
+
+ public static final Task[] sampleTaskData = getSampleTaskData();
+
+ private static Task[] getSampleTaskData() {
+ try {
+ return new Task[]{
+ new Task(new Name("Ali Muster"), new DueDate("9482424"), new DueDate("9482424"), new Address("4th street"), new Priority("4"), new UniqueTagList()),
+ new Task(new Name("Boris Mueller"), new DueDate("9482424"), new DueDate("87249245"), new Address("81th street"), new Priority("3"), new UniqueTagList()),
+ new Task(new Name("Carl Kurz"), new DueDate("9482424"), new DueDate("95352563"), new Address("wall street"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Daniel Meier"), new DueDate("9482424"), new DueDate("87652533"), new Address("10th street"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Elle Meyer"), new DueDate("9482424"), new DueDate("9482224"), new Address("michegan ave"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Fiona Kunz"), new DueDate("9482424"), new DueDate("9482427"), new Address("little tokyo"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("George Best"), new DueDate("9482424"), new DueDate("9482442"), new Address("4th street"), new Priority("4"), new UniqueTagList()),
+ new Task(new Name("Hoon Meier"), new DueDate("9482424"), new DueDate("8482424"), new Address("little india"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Ida Mueller"), new DueDate("9482424"), new DueDate("8482131"), new Address("chicago ave"), new Priority("1"), new UniqueTagList())
+ };
+ } catch (IllegalValueException e) {
+ assert false;
+ //not possible
+ return null;
+ }
+ }
+
+ public static final Tag[] sampleTagData = getSampleTagData();
+
+ private static Tag[] getSampleTagData() {
+ try {
+ return new Tag[]{
+ new Tag("relatives"),
+ new Tag("friends")
+ };
+ } catch (IllegalValueException e) {
+ assert false;
+ return null;
+ //not possible
+ }
+ }
+
+ public static List generateSampleTaskData() {
+ return Arrays.asList(sampleTaskData);
+ }
+
+ /**
+ * Appends the file name to the sandbox folder path.
+ * Creates the sandbox folder if it doesn't exist.
+ * @param fileName
+ * @return
+ */
+ public static String getFilePathInSandboxFolder(String fileName) {
+ try {
+ FileUtil.createDirs(new File(SANDBOX_FOLDER));
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ return SANDBOX_FOLDER + fileName;
+ }
+
+ public static void createDataFileWithSampleData(String filePath) {
+ createDataFileWithData(generateSampleStorageAddressBook(), filePath);
+ }
+
+ public static void createDataFileWithData(T data, String filePath) {
+ try {
+ File saveFileForTesting = new File(filePath);
+ FileUtil.createIfMissing(saveFileForTesting);
+ XmlUtil.saveDataToFile(saveFileForTesting, data);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void main(String... s) {
+ createDataFileWithSampleData(TestApp.SAVE_LOCATION_FOR_TESTING);
+ }
+
+ public static AddressBook generateEmptyAddressBook() {
+ return new AddressBook(new UniqueTaskList(), new UniqueTagList());
+ }
+
+ public static XmlSerializableAddressBook generateSampleStorageAddressBook() {
+ return new XmlSerializableAddressBook(generateEmptyAddressBook());
+ }
+
+ /**
+ * Tweaks the {@code keyCodeCombination} to resolve the {@code KeyCode.SHORTCUT} to their
+ * respective platform-specific keycodes
+ */
+ public static KeyCode[] scrub(KeyCodeCombination keyCodeCombination) {
+ List keys = new ArrayList<>();
+ if (keyCodeCombination.getAlt() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.ALT);
+ }
+ if (keyCodeCombination.getShift() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.SHIFT);
+ }
+ if (keyCodeCombination.getMeta() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.META);
+ }
+ if (keyCodeCombination.getControl() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.CONTROL);
+ }
+ keys.add(keyCodeCombination.getCode());
+ return keys.toArray(new KeyCode[]{});
+ }
+
+ public static boolean isHeadlessEnvironment() {
+ String headlessProperty = System.getProperty("testfx.headless");
+ return headlessProperty != null && headlessProperty.equals("true");
+ }
+
+ public static void captureScreenShot(String fileName) {
+ File file = GuiTest.captureScreenshot();
+ try {
+ Files.copy(file, new File(fileName + ".png"));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static String descOnFail(Object... comparedObjects) {
+ return "Comparison failed \n"
+ + Arrays.asList(comparedObjects).stream()
+ .map(Object::toString)
+ .collect(Collectors.joining("\n"));
+ }
+
+ public static void setFinalStatic(Field field, Object newValue) throws NoSuchFieldException, IllegalAccessException{
+ field.setAccessible(true);
+ // remove final modifier from field
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ // ~Modifier.FINAL is used to remove the final modifier from field so that its value is no longer
+ // final and can be changed
+ modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+ field.set(null, newValue);
+ }
+
+ public static void initRuntime() throws TimeoutException {
+ FxToolkit.registerPrimaryStage();
+ FxToolkit.hideStage();
+ }
+
+ public static void tearDownRuntime() throws Exception {
+ FxToolkit.cleanupStages();
+ }
+
+ /**
+ * Gets private method of a class
+ * Invoke the method using method.invoke(objectInstance, params...)
+ *
+ * Caveat: only find method declared in the current Class, not inherited from supertypes
+ */
+ public static Method getPrivateMethod(Class objectClass, String methodName) throws NoSuchMethodException {
+ Method method = objectClass.getDeclaredMethod(methodName);
+ method.setAccessible(true);
+ return method;
+ }
+
+ public static void renameFile(File file, String newFileName) {
+ try {
+ Files.copy(file, new File(newFileName));
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ }
+ }
+
+ /**
+ * Gets mid point of a node relative to the screen.
+ * @param node
+ * @return
+ */
+ public static Point2D getScreenMidPoint(Node node) {
+ double x = getScreenPos(node).getMinX() + node.getLayoutBounds().getWidth() / 2;
+ double y = getScreenPos(node).getMinY() + node.getLayoutBounds().getHeight() / 2;
+ return new Point2D(x,y);
+ }
+
+ /**
+ * Gets mid point of a node relative to its scene.
+ * @param node
+ * @return
+ */
+ public static Point2D getSceneMidPoint(Node node) {
+ double x = getScenePos(node).getMinX() + node.getLayoutBounds().getWidth() / 2;
+ double y = getScenePos(node).getMinY() + node.getLayoutBounds().getHeight() / 2;
+ return new Point2D(x,y);
+ }
+
+ /**
+ * Gets the bound of the node relative to the parent scene.
+ * @param node
+ * @return
+ */
+ public static Bounds getScenePos(Node node) {
+ return node.localToScene(node.getBoundsInLocal());
+ }
+
+ public static Bounds getScreenPos(Node node) {
+ return node.localToScreen(node.getBoundsInLocal());
+ }
+
+ public static double getSceneMaxX(Scene scene) {
+ return scene.getX() + scene.getWidth();
+ }
+
+ public static double getSceneMaxY(Scene scene) {
+ return scene.getX() + scene.getHeight();
+ }
+
+ public static Object getLastElement(List list) {
+ return list.get(list.size() - 1);
+ }
+
+ /**
+ * Removes a subset from the list of tasks.
+ * @param tasks The list of tasks
+ * @param tasksToRemove The subset of tasks.
+ * @return The modified tasks after removal of the subset from tasks.
+ */
+ public static TestTask[] removeTasksFromList(final TestTask[] tasks, TestTask... tasksToRemove) {
+ List listOfTasks = asList(tasks);
+ listOfTasks.removeAll(asList(tasksToRemove));
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+
+ /**
+ * Returns a copy of the list with the task at specified index removed.
+ * @param list original list to copy from
+ * @param targetIndexInOneIndexedFormat e.g. if the first element to be removed, 1 should be given as index.
+ */
+ public static TestTask[] removeTaskFromList(final TestTask[] list, int targetIndexInOneIndexedFormat) {
+ return removeTasksFromList(list, list[targetIndexInOneIndexedFormat-1]);
+ }
+
+ /**
+ * Replaces tasks[i] with a task.
+ * @param tasks The array of tasks.
+ * @param task The replacement task
+ * @param index The index of the task to be replaced.
+ * @return
+ */
+ public static TestTask[] replaceTaskFromList(TestTask[] tasks, TestTask task, int index) {
+ tasks[index] = task;
+ return tasks;
+ }
+
+ /**
+ * Appends tasks to the array of tasks.
+ * @param tasks A array of tasks.
+ * @param tasksToAdd The tasks that are to be appended behind the original array.
+ * @return The modified array of tasks.
+ */
+ public static TestTask[] addTasksToList(final TestTask[] tasks, TestTask... tasksToAdd) {
+ List listOfTasks = asList(tasks);
+ listOfTasks.addAll(asList(tasksToAdd));
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+```
+###### /seedu/gtd/testutil/TestUtil.java
+``` java
+
+ private static List asList(T[] objs) {
+ List list = new ArrayList<>();
+ for(T obj : objs) {
+ list.add(obj);
+ }
+ return list;
+ }
+
+ public static boolean compareCardAndTask(TaskCardHandle card, ReadOnlyTask task) {
+ return card.isSameTask(task);
+ }
+
+ public static Tag[] getTagList(String tags) {
+
+ if (tags.equals("")) {
+ return new Tag[]{};
+ }
+
+ final String[] split = tags.split(", ");
+
+ final List collect = Arrays.asList(split).stream().map(e -> {
+ try {
+ return new Tag(e.replaceFirst("Tag: ", ""));
+ } catch (IllegalValueException e1) {
+ //not possible
+ assert false;
+ return null;
+ }
+ }).collect(Collectors.toList());
+
+ return collect.toArray(new Tag[split.length]);
+ }
+
+}
+```
diff --git a/collated/test/generated.md b/collated/test/generated.md
new file mode 100644
index 000000000000..f87705a9bdf4
--- /dev/null
+++ b/collated/test/generated.md
@@ -0,0 +1,257 @@
+# generated
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+
+ /**
+ * Confirms the 'invalid argument index number behaviour' for the given command
+ * targeting a single task in the shown list, using visible index.
+ * @param commandWord to test assuming it targets a single task in the last shown list based on visible index.
+ */
+ private void assertIncorrectIndexFormatBehaviorForCommand(String commandWord, String expectedMessage) throws Exception {
+ assertCommandBehavior(commandWord , expectedMessage); //index missing
+ assertCommandBehavior(commandWord + " +1", expectedMessage); //index should be unsigned
+ assertCommandBehavior(commandWord + " -1", expectedMessage); //index should be unsigned
+ assertCommandBehavior(commandWord + " 0", expectedMessage); //index cannot be 0
+ assertCommandBehavior(commandWord + " not_a_number", expectedMessage);
+ }
+
+ /**
+ * Confirms the 'invalid argument index number behaviour' for the given command
+ * targeting a single task in the shown list, using visible index.
+ * @param commandWord to test assuming it targets a single task in the last shown list based on visible index.
+ */
+ private void assertIndexNotFoundBehaviorForCommand(String commandWord) throws Exception {
+ String expectedMessage = MESSAGE_INVALID_TASK_DISPLAYED_INDEX;
+ TestDataHelper helper = new TestDataHelper();
+ List taskList = helper.generateTaskList(2);
+
+ // set AB state to 2 tasks
+ model.clearTaskList();
+ for (Task p : taskList) {
+ model.addTask(p);
+ }
+
+ assertCommandBehavior(commandWord + " 3", expectedMessage, model.getAddressBook(), taskList);
+ }
+
+ @Test
+ public void execute_selectInvalidArgsFormat_errorMessageShown() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, SelectCommand.MESSAGE_USAGE);
+ assertIncorrectIndexFormatBehaviorForCommand("select", expectedMessage);
+ }
+
+ @Test
+ public void execute_selectIndexNotFound_errorMessageShown() throws Exception {
+ assertIndexNotFoundBehaviorForCommand("select");
+ }
+
+ @Test
+ public void execute_select_jumpsToCorrectTask() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ List threeTasks = helper.generateTaskList(3);
+
+ AddressBook expectedAB = helper.generateAddressBook(threeTasks);
+ helper.addToModel(model, threeTasks);
+
+ assertCommandBehavior("select 2",
+ String.format(SelectCommand.MESSAGE_SELECT_TASK_SUCCESS, 2),
+ expectedAB,
+ expectedAB.getTaskList());
+ assertEquals(1, targetedJumpIndex);
+ assertEquals(model.getFilteredTaskList().get(1), threeTasks.get(1));
+ }
+
+
+ @Test
+ public void execute_deleteInvalidArgsFormat_errorMessageShown() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE);
+ assertIncorrectIndexFormatBehaviorForCommand("delete", expectedMessage);
+ }
+
+ @Test
+ public void execute_deleteIndexNotFound_errorMessageShown() throws Exception {
+ assertIndexNotFoundBehaviorForCommand("delete");
+ }
+
+ @Test
+ public void execute_delete_removesCorrectTask() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ List threeTasks = helper.generateTaskList(3);
+
+ AddressBook expectedAB = helper.generateAddressBook(threeTasks);
+ expectedAB.removeTask(threeTasks.get(1));
+ helper.addToModel(model, threeTasks);
+
+ assertCommandBehavior("delete 2",
+ String.format(DeleteCommand.MESSAGE_DELETE_TASK_SUCCESS, threeTasks.get(1)),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+
+ @Test
+ public void execute_find_invalidArgsFormat() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, FindCommand.MESSAGE_USAGE);
+ assertCommandBehavior("find ", expectedMessage);
+ }
+
+ @Test
+ public void execute_find_onlyMatchesFullWordsInNames() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task pTarget1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task pTarget2 = helper.generateTaskWithName("bla KEY bla bceofeia");
+ Task p1 = helper.generateTaskWithName("KE Y");
+ Task p2 = helper.generateTaskWithName("KEYKEYKEY sduauo");
+
+ List fourTasks = helper.generateTaskList(p1, pTarget1, p2, pTarget2);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = helper.generateTaskList(pTarget1, pTarget2);
+ helper.addToModel(model, fourTasks);
+
+ assertCommandBehavior("find KEY",
+ Command.getMessageForTaskListShownSummary(expectedList.size()),
+ expectedAB,
+ expectedList);
+ }
+
+ @Test
+ public void execute_find_isNotCaseSensitive() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task p1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task p2 = helper.generateTaskWithName("bla KEY bla bceofeia");
+ Task p3 = helper.generateTaskWithName("key key");
+ Task p4 = helper.generateTaskWithName("KEy sduauo");
+
+ List fourTasks = helper.generateTaskList(p3, p1, p4, p2);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = fourTasks;
+ helper.addToModel(model, fourTasks);
+
+ assertCommandBehavior("find KEY",
+ Command.getMessageForTaskListShownSummary(expectedList.size()),
+ expectedAB,
+ expectedList);
+ }
+
+ @Test
+ public void execute_find_matchesIfAnyKeywordPresent() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task pTarget1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task pTarget2 = helper.generateTaskWithName("bla rAnDoM bla bceofeia");
+ Task pTarget3 = helper.generateTaskWithName("key key");
+ Task p1 = helper.generateTaskWithName("sduauo");
+
+ List fourTasks = helper.generateTaskList(pTarget1, p1, pTarget2, pTarget3);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = helper.generateTaskList(pTarget1, pTarget2, pTarget3);
+ helper.addToModel(model, fourTasks);
+
+ String keywords = "key rAnDoM";
+ TestFindHelper findhelper = new TestFindHelper();
+
+ assertCommandBehavior("find " + keywords,
+ String.format(findhelper.generateCorrectResultIfExactPhraseNotFound(keywords, expectedList.size())),
+ expectedAB,
+ expectedList);
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ class TestFindHelper{
+
+ String generateCorrectResultIfExactPhraseNotFound(String keywords, int expectedListSize) {
+ String task_tasks = (expectedListSize == 1) ? "task" : "tasks";
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found. Listing " + expectedListSize + " " + task_tasks + " containing the keywords entered instead.";
+ return MESSAGE_IF_EXACT_PHRASE_NOT_FOUND;
+ }
+ }
+
+```
+###### /seedu/gtd/logic/LogicManagerTest.java
+``` java
+ /**
+ * Generates an AddressBook with auto-generated tasks.
+ */
+ AddressBook generateAddressBook(int numGenerated) throws Exception{
+ AddressBook addressBook = new AddressBook();
+ addToAddressBook(addressBook, numGenerated);
+ return addressBook;
+ }
+
+ /**
+ * Generates an AddressBook based on the list of Tasks given.
+ */
+ AddressBook generateAddressBook(List tasks) throws Exception{
+ AddressBook addressBook = new AddressBook();
+ addToAddressBook(addressBook, tasks);
+ return addressBook;
+ }
+
+ /**
+ * Adds auto-generated Task objects to the given AddressBook
+ * @param addressBook The AddressBook to which the Tasks will be added
+ */
+ void addToAddressBook(AddressBook addressBook, int numGenerated) throws Exception{
+ addToAddressBook(addressBook, generateTaskList(numGenerated));
+ }
+
+ /**
+ * Adds the given list of Tasks to the given AddressBook
+ */
+ void addToAddressBook(AddressBook addressBook, List tasksToAdd) throws Exception{
+ for(Task p: tasksToAdd){
+ addressBook.addTask(p);
+ }
+ }
+
+ /**
+ * Adds auto-generated Task objects to the given model
+ * @param model The model to which the Tasks will be added
+ */
+ void addToModel(Model model, int numGenerated) throws Exception{
+ addToModel(model, generateTaskList(numGenerated));
+ }
+
+ /**
+ * Adds the given list of Tasks to the given model
+ */
+ void addToModel(Model model, List tasksToAdd) throws Exception{
+ for(Task p: tasksToAdd){
+ model.addTask(p);
+ }
+ }
+
+ /**
+ * Generates a list of Tasks based on the flags.
+ */
+ List generateTaskList(int numGenerated) throws Exception{
+ List tasks = new ArrayList<>();
+ for(int i = 1; i <= numGenerated; i++){
+ tasks.add(generateTask(i));
+ }
+ return tasks;
+ }
+
+ List generateTaskList(Task... tasks) {
+ return Arrays.asList(tasks);
+ }
+
+ /**
+ * Generates a Task object with given name. Other fields will have some dummy values.
+ */
+ Task generateTaskWithName(String name) throws Exception {
+ return new Task(
+ new Name(name),
+ new DueDate("3"),
+ new DueDate("1"),
+ new Address("House of 1"),
+ new Priority("1"),
+ new UniqueTagList(new Tag("tag"))
+ );
+ }
+ }
+}
+```
diff --git a/config/findbugs/excludeFilter.xml b/config/findbugs/excludeFilter.xml
index 03c15ae4cc81..69406bf4ab5e 100644
--- a/config/findbugs/excludeFilter.xml
+++ b/config/findbugs/excludeFilter.xml
@@ -6,7 +6,7 @@
-
+
diff --git a/docs/AboutUs.md b/docs/AboutUs.md
index 33df65bea583..c8763d2942c6 100644
--- a/docs/AboutUs.md
+++ b/docs/AboutUs.md
@@ -4,49 +4,73 @@ We are a team based in the [School of Computing, National University of Singapor
## Project Team
-#### [Damith C. Rajapakse](http://www.comp.nus.edu.sg/~damithch)
-
-**Role**: Project Advisor
+#### [Ravi Shwetha](http://github.com/ravishwetha)
+
+* Components in charge of: [Storage and Testing](https://github.com/se-edu/addressbook-level4/blob/master/docs/DeveloperGuide.md#storage-component)
+* Aspects/tools in charge of: Testing, Git
+* Features implemented:
+ * [Basic undo and multiple undo](https://github.com/se-edu/addressbook-level4/blob/master/docs/UserGuide.md#listing-all-persons--list)
+ * [Edit task](https://github.com/se-edu/addressbook-level4/blob/master/docs/UserGuide.md#deleting-a-person--delete)
+ * [Find searches for exact keywords first](https://github.com/se-edu/addressbook-level4/blob/master/docs/UserGuide.md#deleting-a-person--delete)
+ * [Natural language processing for dates using Natty API](https://github.com/se-edu/addressbook-level4/blob/master/docs/UserGuide.md#deleting-a-person--delete)
+* Code written: [[functional code](A0146130W.md)][[test code](A0146130W.md)][[docs](A0146130W.md)]
+* Other major contributions:
+ * Did the initial refactoring from Person model to Task model [[#133](https://github.com/se-edu/addressbook-level4/pull/152) ]
+ * Set up Coveralls and Collate
+ * Change browser to search task location on google maps
+
-----
-#### [Joshua Lee](http://github.com/lejolly)
-
+#### [Tan Shao Yun](http://github.com/shaocloud)
+
Role: Developer
-Responsibilities: UI
+* Components in charge of: [UI, Design](https://github.com/CS2103AUG2016-F10-C3/main/blob/master/docs/DeveloperGuide.md#design)
+* Features implemented:
+ * [Reordered UI](https://github.com/CS2103AUG2016-F10-C3/main/tree/master/src/main/resources/view)
+ * [UML Design](https://github.com/CS2103AUG2016-F10-C3/main/blob/master/docs/DeveloperGuide.md)
+* Other major contributions:
+ * [Designed Screenshots](https://github.com/CS2103AUG2016-F10-C3/main/blob/master/docs/images/Ui.jpg)
+ * [Designed icon](https://github.com/CS2103AUG2016-F10-C3/main/tree/master/src/main/resources/tary.png)
-----
-#### [Leow Yijin](http://github.com/yijinl)
-
-Role: Developer
-Responsibilities: Data
-
------
-
-#### [Martin Choo](http://github.com/m133225)
-
-Role: Developer
-Responsibilities: Dev Ops
-
------
-
-#### [Thien Nguyen](https://github.com/ndt93)
- Role: Developer
- Responsibilities: Threading
+#### [Voon Soo Yin](http://github.com/tessav)
+
- -----
+* Components in charge of: [Logic](https://github.com/se-edu/addressbook-level4/blob/master/docs/DeveloperGuide.md#logic-component)
+* Aspects/tools in charge of: Documentation, Travis
+* Features implemented:
+ * [Add task with flexibility in command format]()
+ * [Add floating task and event task]()
+ * [Find task by each field type]()
+ * [Mark task as done]()
+ * [Separate listing of tasks that are done/not done]()
+* Code written: [[functional code](A0130677A.md)][[test code](A0130677A.md)][[docs](A0130677A.md)]
+* Other major contributions:
+ * Command format validation & regex
+ * Set up Travis
+ * Complete user guide
+
+------
-#### [You Liang](http://github.com/yl-coder)
-
- Role: Developer
- Responsibilities: UI
+#### [Nyan Lin Cho](http://github.com/NachosNLC)
+
- -----
+* Components in charge of: [Model](https://github.com/se-edu/addressbook-level4/blob/master/docs/DeveloperGuide.md#model-component)
+* Aspects/tools in charge of: Model
+* Features implemented:
+ * [Extended Help Command to view individual command help]()
+* Code written: [[functional code](A0139158X.md)][[test code](A0139158X.md)][[docs](A0139158X.md)]
-# Contributors
+------
-We welcome contributions. See [Contact Us](ContactUs.md) page for more info.
+# Acknowledgements
-* [Akshay Narayan](https://github.com/se-edu/addressbook-level4/pulls?q=is%3Apr+author%3Aokkhoy)
-* [Sam Yong](https://github.com/se-edu/addressbook-level4/pulls?q=is%3Apr+author%3Amauris)
\ No newline at end of file
+#### [Chan Jun Wei](http://github.com/chanjunweimy)
+
+ Role: Module Tutor and Project Supervisor
+
+ -----
+
+Code modified from : https://github.com/nus-cs2103-AY1617S1/addressbook-level4
diff --git a/docs/ContactUs.md b/docs/ContactUs.md
index 866d0de3fddc..baf2113e0f05 100644
--- a/docs/ContactUs.md
+++ b/docs/ContactUs.md
@@ -1,8 +1,8 @@
# Contact Us
-* **Bug reports, Suggestions** : Post in our [issue tracker](https://github.com/se-edu/addressbook-level4/issues)
+* **Bug reports, Suggestions** : Post in our [issue tracker](https://github.com/CS2103AUG2016-F10-C3/main/issues)
if you noticed bugs or have suggestions on how to improve.
* **Contributing** : We welcome pull requests. Follow the process described [here](https://github.com/oss-generic/process)
-* **Email us** : You can also reach us at `damith [at] comp.nus.edu.sg`
\ No newline at end of file
+* **Email us** : You can also reach us at `a0130677@u.nus.edu`
diff --git a/docs/DeveloperGuide.md b/docs/DeveloperGuide.md
index bc710ed45eb9..78b40a0de412 100644
--- a/docs/DeveloperGuide.md
+++ b/docs/DeveloperGuide.md
@@ -45,8 +45,9 @@
## Design
### Architecture
-
-
+
+
+
The **_Architecture Diagram_** given above explains the high-level design of the App.
Given below is a quick overview of each component.
@@ -72,19 +73,24 @@ Each of the four components
For example, the `Logic` component (see the class diagram given below) defines it's API in the `Logic.java`
interface and exposes its functionality using the `LogicManager.java` class.
-
+
+
+
The _Sequence Diagram_ below shows how the components interact for the scenario where the user issues the
command `delete 3`.
+
+
+
-
-
->Note how the `Model` simply raises a `AddressBookChangedEvent` when the Address Book data are changed,
+>Note how the `Model` simply raises a `AddressBookChangedEvent` when the GTD data are changed,
instead of asking the `Storage` to save the updates to the hard disk.
The diagram below shows how the `EventsCenter` reacts to that event, which eventually results in the updates
being saved to the hard disk and the status bar of the UI being updated to reflect the 'Last Updated' time.
-
+
+
+
> Note how the event is propagated through the `EventsCenter` to the `Storage` and `UI` without `Model` having
to be coupled to either of them. This is an example of how this Event Driven approach helps us reduce direct
@@ -93,12 +99,13 @@ being saved to the hard disk and the status bar of the UI being updated to refle
The sections below give more details of each component.
### UI component
-
-
+
+
+
**API** : [`Ui.java`](../src/main/java/seedu/address/ui/Ui.java)
-The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `PersonListPanel`,
+The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `TaskListPanel`,
`StatusBarFooter`, `BrowserPanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class
and they can be loaded using the `UiPartLoader`.
@@ -113,42 +120,43 @@ The `UI` component,
* Responds to events raised from various parts of the App and updates the UI accordingly.
### Logic component
-
-
-
+
+
+
**API** : [`Logic.java`](../src/main/java/seedu/address/logic/Logic.java)
1. `Logic` uses the `Parser` class to parse the user command.
2. This results in a `Command` object which is executed by the `LogicManager`.
-3. The command execution can affect the `Model` (e.g. adding a person) and/or raise events.
+3. The command execution can affect the `Model` (e.g. adding a task) and/or raise events.
4. The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
Given below is the Sequence Diagram for interactions within the `Logic` component for the `execute("delete 1")`
API call.
-
-
+
+
+
### Model component
-
-
-
+
+
+
**API** : [`Model.java`](../src/main/java/seedu/address/model/Model.java)
The `Model`,
* stores a `UserPref` object that represents the user's preferences.
-* stores the Address Book data.
-* exposes a `UnmodifiableObservableList` that can be 'observed' e.g. the UI can be bound to this list
+* stores the GTD data.
+* exposes a `UnmodifiableObservableList` that can be 'observed' e.g. the UI can be bound to this list
so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.
### Storage component
-
-
-
+
+
+
**API** : [`Storage.java`](../src/main/java/seedu/address/storage/Storage.java)
The `Storage` component,
* can save `UserPref` objects in json format and read it back.
-* can save the Address Book data in xml format and read it back.
+* can save the GTD data in xml format and read it back.
### Common classes
@@ -241,41 +249,48 @@ Here are the steps to create a new release.
### Managing Dependencies
-A project often depends on third-party libraries. For example, Address Book depends on the
+A project often depends on third-party libraries. For example, Tarydepends on the
[Jackson library](http://wiki.fasterxml.com/JacksonHome) for XML parsing. Managing these _dependencies_
can be automated using Gradle. For example, Gradle can download the dependencies automatically, which
is better than these alternatives.
a. Include those libraries in the repo (this bloats the repo size)
b. Require developers to download those libraries manually (this creates extra work for developers)
+
+
## Appendix A : User Stories
Priorities: High (must have) - `* * *`, Medium (nice to have) - `* *`, Low (unlikely to have) - `*`
-
Priority | As a ... | I want to ... | So that I can...
-------- | :-------- | :--------- | :-----------
-`* * *` | new user | see usage instructions | refer to instructions when I forget how to use the App
-`* * *` | user | add a new person |
-`* * *` | user | delete a person | remove entries that I no longer need
-`* * *` | user | find a person by name | locate details of persons without having to go through the entire list
-`* *` | user | hide [private contact details](#private-contact-detail) by default | minimize chance of someone else seeing them by accident
-`*` | user with many persons in the address book | sort persons by name | locate a person easily
-
-{More to be added}
+`* * *` | new user | see usage instructions | refer to instructions when I forget how to use the application
+`* * *` | user | add a task with a deadline | be reminded of tasks that I have to complete soon and prioritise them
+`* * ` | user | add a task with a priority rank | view a prioritised list of tasks and know which task to start with
+`* * ` | user | add a task with a location | immediately know the location and context without having to refer to other sources
+`* * *` | user | add a task with tag(s) | search or filter tasks by these tags
+`* * ` | user | select a task to access widgets like Google Calendar and Google Maps | immediately connect with these frequently used applications, without having to take more steps such as opening a browser and visiting the link, and typing in the search bar
+`* * *` | user | delete a task | remove clutter from the task list
+`* * *` | user | find a task by title | find tasks easily
+`* * *` | user | find a task by tags | categorise and find tasks easily
+`* * *` | user | edit information about a task | update the task (such as adding a deadline or location) when more information is available or when changes arise
+`* * *` | user | view all tasks entered | have a quick summary of what tasks I have
+`* * *` | user | clear all tasks | reset the task list
+
+
## Appendix B : Use Cases
-(For all use cases below, the **System** is the `AddressBook` and the **Actor** is the `user`, unless specified otherwise)
+(For all use cases below, the **System** is the `GTD` and the **Actor** is the `user`, unless specified otherwise)
-#### Use case: Delete person
+#### Use case: Delete task
**MSS**
1. User requests to list persons
-2. AddressBook shows a list of persons
+2. GTD shows a list of persons
3. User requests to delete a specific person in the list
-4. AddressBook deletes the person
+4. GTD deletes the person
Use case ends.
**Extensions**
@@ -286,7 +301,7 @@ Use case ends.
3a. The given index is invalid
-> 3a1. AddressBook shows an error message
+> 3a1. GTD shows an error message
Use case resumes at step 2
{More to be added}
@@ -294,7 +309,7 @@ Use case ends.
## Appendix C : Non Functional Requirements
1. Should work on any [mainstream OS](#mainstream-os) as long as it has Java `1.8.0_60` or higher installed.
-2. Should be able to hold up to 1000 persons.
+2. Should be able to hold up to 10,000 tasks.
3. Should come with automated unit tests and open source code.
4. Should favor DOS style commands over Unix-style commands.
@@ -306,11 +321,28 @@ Use case ends.
> Windows, Linux, Unix, OS-X
-##### Private contact detail
-
-> A contact detail that is not meant to be shared with others
+
## Appendix E : Product Survey
-{TODO: Add a summary of competing products}
-
+Reminders for Mac: Simple, clean white interface that is close to a text editor. Mouse use for interaction only required for tags, adding and deleting.
+Features:
+a) tags can be added to items on the list like date due and priority
+b) schedule tab can arrange the reminders by due date
+c) iCloud sync allows use on laptop and phone
+d) periodic tasks can be set such that a reminder alert is displayed every time it is due.
+
+Drawbacks:
+a) Need to refer to calendar to set due dates.
+
+Asana: Collaborative GTD, a team can set up project tasks and subgroups that divide people into smaller groups based on tasks (Marketing, Engineering, etc).
+a) Can setup individual tasks on personal dashboard, so it also works well for individual use.
+b) Can hold conversations with team members.
+c) Can set up team tasks.
+d) Can divide members into smaller groups for better organisation.
+
+Taskwarrior: feature-rich software that allows the user to manage his todo list from the command line.
+Uses a natural and expressive syntax
+Allows user to perform CRUD functions and prioritising of tasks in a fast manner
+Support for creating deadlines, searching of tasks
+However, it does not support Jim’s need for “blocking� and “unblocking� timeslots
diff --git a/docs/UserGuide.md b/docs/UserGuide.md
index 0cf4b84f7470..879aba4ae4a1 100644
--- a/docs/UserGuide.md
+++ b/docs/UserGuide.md
@@ -8,127 +8,178 @@
## Quick Start
0. Ensure you have Java version `1.8.0_60` or later installed in your Computer.
- > Having any Java 8 version is not enough.
- This app will not work with earlier versions of Java 8.
-
-1. Download the latest `addressbook.jar` from the [releases](../../../releases) tab.
+Having any Java 8 version is not enough.
+This app will not work with earlier versions of Java 8.
+1. Download the latest `taryapp.jar` from the [releases](../../../releases) tab.
2. Copy the file to the folder you want to use as the home folder for your Address Book.
-3. Double-click the file to start the app. The GUI should appear in a few seconds.
- > 
+3. Double-click the file to start the app. The GUI should appear in a few seconds.
+
+
4. Type the command in the command box and press Enter to execute it.
e.g. typing **`help`** and pressing Enter will open the help window.
5. Some example commands you can try:
- * **`list`** : lists all contacts
- * **`add`**` John Doe p/98765432 e/johnd@gmail.com a/John street, block 123, #01-01` :
- adds a contact named `John Doe` to the Address Book.
- * **`delete`**` 3` : deletes the 3rd contact shown in the current list
+ * **`list`** : lists all tasks to be done
+ * **`add`**` add Visit Dentist d/18-11-2016 a/Mount Elizabeth` :
+ adds a task named `Visit Dentist` to the Task List.
+ * **`delete`**` 3` : deletes the 3rd task shown in the current list
* **`exit`** : exits the app
6. Refer to the [Features](#features) section below for details of each command.
-
## Features
-
-> **Command Format**
-> * Words in `UPPER_CASE` are the parameters.
-> * Items in `SQUARE_BRACKETS` are optional.
-> * Items with `...` after them can have multiple instances.
-> * The order of parameters is fixed.
-
-#### Viewing help : `help`
+
+### Command Format
+* Words in `UPPER_CASE` are the parameters.
+* Items in `SQUARE_BRACKETS` are optional.
+* Items with `...` after them can have multiple instances.
+* The order of parameters is fixed.
+
+
+### Viewing help : `help`
Format: `help`
-
-> Help is also shown if you enter an incorrect command e.g. `abcd`
-
-#### Adding a person: `add`
-Adds a person to the address book
-Format: `add NAME p/PHONE_NUMBER e/EMAIL a/ADDRESS [t/TAG]...`
-
-> Persons can have any number of tags (including 0)
+* Help is also shown if you enter an incorrect command e.g. `abcd`
+
+
+### Adding a person: `add`
+**Format:** `add NAME [a/LOCATION s/START_DATE d/DEADLINE_OR_END_DATE p/PRIORITY t/TAGS]`
+* Adds a task to the task list in a flexible format (in any order).
+* All parameters except name are optional.
+* This command supports 3 types of tasks: floating tasks, event tasks and deadline tasks.
+* Persons can have any number of tags (including 0)
+
+Examples:
+* Floating task: `add Visit Dentist`
+* Event task: `add hackathon a/NUS s/tomorrow d/sunday p/3 t/preparation`
+* Deadline task: `add submit tutorial d/monday p/5`
+
+**Field Type Constraints**
+* Task duedate or startdate is formatted like the following: Wed Nov 02 15:39:55 UTC 2016
+* Accepted formal dates: 1978-01-28, 1984/04/02, 1/02/1980, 2/28/79
+* Relaxed dates: The 31st of April in the year 2008, Fri, 21 Nov 1997, Jan 21, '97, Sun, Nov 21, jan 1st, february twenty-eighth
+* Relative dates: next thursday, last wednesday, today, tomorrow, yesterday, next week, next month, next year, 3 days from * now, three weeks ago
+* Prefixes: day after, the day before, the monday after, the monday before, 2 fridays before, 4 tuesdays after
+* Time: 0600h, 06:00 hours, 6pm, 5:30 a.m., 5, 12:59, 23:59, 8p, noon, afternoon, midnight
+* Relative times: 10 seconds ago, in 5 minutes, 4 minutes from now.
+
+
+### Mark task as done : `done`
+Format: `done INDEX`
+Marks a task as done by the index displayed on the task panel.
+* tasks marked as done can be shown when using command 'list done'
+* once marked as done, cannot be undone unless using `undone` command immediately
+
+
+### Edit task by attributes: `edit`
+Format: `edit INDEX [NEW_NAME] FIELD_TYPE/NEW_FIELD_DETAILS`
+Edits a task as done by the index displayed on the task panel.
+* to change the name only, use `edit NEW_NAME` without specifying field type
+* able to accept multiple field types e.g. `edit 2 taskA a/NUS d/friday`
+
+
+### Undo previous command: `undo`
+Format: `undo`
+Undo the last command.
+* multiple undos supported.
+
+
+### Listing all tasks : `list`
+Format: `list [done]`
+Shows a list of all tasks done or not done in the task list.
+* `list` shows all tasks not done
+* `list done` shows all tasks done
+
+
+### Finding all tasks containing any keyword in their name or attributes: `find`
+Format: `find [FIELD_TYPE] KEYWORD`
+Finds tasks whose descriptions contain any of the given keyword.
+* The search is case sensitive. e.g `hmk` will not match `HMK`
+* The order of the keywords does not matter. e.g. `Do Homework` will match `Homework Do`
+* If field type is specified, only the field type will be matched with the keyword
+* If field type is not specified, name will be search for a match first, before searching all the other fields for the keyword.
+* Only full words will be matched e.g. `Hmk` will not match `Hmks`
+* Tasks matching at least one keyword will be returned (i.e. `OR` search).
+ e.g. `Hmk` will match `Do Hmk`
Examples:
-* `add John Doe p/98765432 e/johnd@gmail.com a/John street, block 123, #01-01`
-* `add Betsy Crowe p/1234567 e/betsycrowe@gmail.com a/Newgate Prison t/criminal t/friend`
-
-#### Listing all persons : `list`
-Shows a list of all persons in the address book.
-Format: `list`
+* `find p/3` : Returns any task that has priority 3
+* `find a/NUS` : Returns any task that occurs in NUS
+* `find homework`: Returns task with homework in the name, if not found, returns tasks with homework in other fields such as tags
+
-#### Finding all persons containing any keyword in their name: `find`
-Finds persons whose names contain any of the given keywords.
-Format: `find KEYWORD [MORE_KEYWORDS]`
-
-> * The search is case sensitive. e.g `hans` will not match `Hans`
-> * The order of the keywords does not matter. e.g. `Hans Bo` will match `Bo Hans`
-> * Only the name is searched.
-> * Only full words will be matched e.g. `Han` will not match `Hans`
-> * Persons matching at least one keyword will be returned (i.e. `OR` search).
- e.g. `Hans` will match `Hans Bo`
-
-Examples:
-* `find John`
- Returns `John Doe` but not `john`
-* `find Betsy Tim John`
- Returns Any person having names `Betsy`, `Tim`, or `John`
-
-#### Deleting a person : `delete`
-Deletes the specified person from the address book. Irreversible.
+### Deleting a task : `delete`
+Deletes the specified task from the address book. Irreversible.
Format: `delete INDEX`
-> Deletes the person at the specified `INDEX`.
- The index refers to the index number shown in the most recent listing.
- The index **must be a positive integer** 1, 2, 3, ...
+Deletes the task at the specified `INDEX`.
+The index refers to the index number shown in the most recent listing.
+The index **must be a positive integer** 1, 2, 3, ...
Examples:
* `list`
`delete 2`
- Deletes the 2nd person in the address book.
-* `find Betsy`
+ Deletes the 2nd task in the task list.
+* `find CS2101`
`delete 1`
- Deletes the 1st person in the results of the `find` command.
+ Deletes the 1st task in the results of the `find` command.
+
-#### Select a person : `select`
+### Select a person : `select`
Selects the person identified by the index number used in the last person listing.
Format: `select INDEX`
-> Selects the person and loads the Google search page the person at the specified `INDEX`.
- The index refers to the index number shown in the most recent listing.
- The index **must be a positive integer** 1, 2, 3, ...
+Selects the person and loads the Google Maps for location of the task at the specified `INDEX`.
+The index refers to the index number shown in the most recent listing.
+The index **must be a positive integer** 1, 2, 3, ...
Examples:
* `list`
`select 2`
- Selects the 2nd person in the address book.
-* `find Betsy`
+ Selects the 2nd task in the task list.
+* `find a/NUS`
`select 1`
- Selects the 1st person in the results of the `find` command.
-
-#### Clearing all entries : `clear`
-Clears all entries from the address book.
-Format: `clear`
-
-#### Exiting the program : `exit`
+ Selects the 1st task in the results of the `find` command.
+
+
+### Clearing all entries : `clear`
+Clears all entries from the task list.
+Format: `clear`
+
+
+### Change file path of storage : `setPath`
+Change the path of the task list to be stored to the specified file path.
+Format: `setPath NEW_PATH`
+Example:
+* `setPath data/newfilepath.xml`
+
+
+### Exiting the program : `exit`
Exits the program.
Format: `exit`
+
-#### Saving the data
-Address book data are saved in the hard disk automatically after any command that changes the data.
+### Saving the data
+Task List data are saved in the hard disk automatically after any command that changes the data.
There is no need to save manually.
+
## FAQ
**Q**: How do I transfer my data to another Computer?
**A**: Install the app in the other computer and overwrite the empty data file it creates with
- the file that contains the data of your previous Address Book folder.
-
+ the file that contains the data of your previous Tasks folder.
+
## Command Summary
Command | Format
-------- | :--------
-Add | `add NAME p/PHONE_NUMBER e/EMAIL a/ADDRESS [t/TAG]...`
+Add | `add NAME [s/startdate d/duedate a/address p/priorityrank(1- highest,5-lowest) t/TAG]...`
+Edit | `edit INDEX [NEW_NAME] FIELD_TYPE/NEW_FIELD_DETAILS` where FIELD_TYPE is either `d/` `a/` `s/` `p/`
+Done | `done INDEX`
Clear | `clear`
Delete | `delete INDEX`
-Find | `find KEYWORD [MORE_KEYWORDS]`
-List | `list`
+Find | `find [FIELD_TYPE] KEYWORD` FIELD_TYPE options: `t/` `a/` `s/` `d/` `p/`
+List | `list [done]`
Help | `help`
Select | `select INDEX`
+SetPath | `setPath NEW_FILE_PATH` NEW_FILE_PATH: e.g. `data/newfile.xml`
+Exit | `exit`
diff --git a/docs/UsingGradle.md b/docs/UsingGradle.md
index 578c5f8634c2..2bf08c342563 100644
--- a/docs/UsingGradle.md
+++ b/docs/UsingGradle.md
@@ -35,7 +35,7 @@ Gradle commands look like this:
## Creating the JAR file
* **`shadowJar`**
- Creates the `addressbook.jar` file in the `build/jar` folder, _if the current file is outdated_.
+ Creates the `tary.jar` file in the `build/jar` folder, _if the current file is outdated_.
e.g. `./gradlew shadowJar`
> To force Gradle to create the JAR file even if the current one is up-to-date, you can '`clean`' first.
diff --git a/docs/diagrams/Diagrams.pptx b/docs/diagrams/Diagrams.pptx
index 3c28abe9c1d3..422ba6686c76 100644
Binary files a/docs/diagrams/Diagrams.pptx and b/docs/diagrams/Diagrams.pptx differ
diff --git a/docs/images/ChanJunWei.jpg b/docs/images/ChanJunWei.jpg
new file mode 100644
index 000000000000..9006d5e190e3
Binary files /dev/null and b/docs/images/ChanJunWei.jpg differ
diff --git a/docs/images/DeleteTaskSdForLogic.png b/docs/images/DeleteTaskSdForLogic.png
new file mode 100644
index 000000000000..6a435503ce5a
Binary files /dev/null and b/docs/images/DeleteTaskSdForLogic.png differ
diff --git a/docs/images/LeowYijin.jpg b/docs/images/LeowYijin.jpg
deleted file mode 100644
index adbf62ad9406..000000000000
Binary files a/docs/images/LeowYijin.jpg and /dev/null differ
diff --git a/docs/images/MockupUi.jpg b/docs/images/MockupUi.jpg
new file mode 100644
index 000000000000..5c630f6375c9
Binary files /dev/null and b/docs/images/MockupUi.jpg differ
diff --git a/docs/images/Nachos.jpg b/docs/images/Nachos.jpg
new file mode 100644
index 000000000000..30a3404d8d71
Binary files /dev/null and b/docs/images/Nachos.jpg differ
diff --git a/docs/images/RaviShwetha.jpg b/docs/images/RaviShwetha.jpg
new file mode 100644
index 000000000000..75fb9d59119e
Binary files /dev/null and b/docs/images/RaviShwetha.jpg differ
diff --git a/docs/images/SDforDeleteTask.png b/docs/images/SDforDeleteTask.png
new file mode 100644
index 000000000000..191d1536b262
Binary files /dev/null and b/docs/images/SDforDeleteTask.png differ
diff --git a/docs/images/SDforDeleteTaskEventHandling.png b/docs/images/SDforDeleteTaskEventHandling.png
new file mode 100644
index 000000000000..183f5270e426
Binary files /dev/null and b/docs/images/SDforDeleteTaskEventHandling.png differ
diff --git a/docs/images/ShaoYun.jpg b/docs/images/ShaoYun.jpg
new file mode 100644
index 000000000000..982c35cbfd95
Binary files /dev/null and b/docs/images/ShaoYun.jpg differ
diff --git a/docs/images/SooYin.jpg b/docs/images/SooYin.jpg
new file mode 100644
index 000000000000..8d4ce5f10a99
Binary files /dev/null and b/docs/images/SooYin.jpg differ
diff --git a/docs/images/TaryArchitecture.png b/docs/images/TaryArchitecture.png
new file mode 100644
index 000000000000..2a06e7d443fc
Binary files /dev/null and b/docs/images/TaryArchitecture.png differ
diff --git a/docs/images/TaskLogicClassDiagram.png b/docs/images/TaskLogicClassDiagram.png
new file mode 100644
index 000000000000..fc1bed6e7c7c
Binary files /dev/null and b/docs/images/TaskLogicClassDiagram.png differ
diff --git a/docs/images/TaskModelClassDiagram.png b/docs/images/TaskModelClassDiagram.png
new file mode 100644
index 000000000000..7c21c850dbf2
Binary files /dev/null and b/docs/images/TaskModelClassDiagram.png differ
diff --git a/docs/images/TaskStorageClassDiagram.png b/docs/images/TaskStorageClassDiagram.png
new file mode 100644
index 000000000000..7a63c30592bd
Binary files /dev/null and b/docs/images/TaskStorageClassDiagram.png differ
diff --git a/docs/images/TaskUiClassDiagram.png b/docs/images/TaskUiClassDiagram.png
new file mode 100644
index 000000000000..b4ae4579f2f2
Binary files /dev/null and b/docs/images/TaskUiClassDiagram.png differ
diff --git a/docs/images/Ui.jpg b/docs/images/Ui.jpg
new file mode 100644
index 000000000000..752445ac6355
Binary files /dev/null and b/docs/images/Ui.jpg differ
diff --git a/docs/images/Ui.png b/docs/images/Ui.png
deleted file mode 100644
index 7121a50a442a..000000000000
Binary files a/docs/images/Ui.png and /dev/null differ
diff --git a/docs/images/Architecture.png b/docs/images/oldPics/Architecture.png
similarity index 100%
rename from docs/images/Architecture.png
rename to docs/images/oldPics/Architecture.png
diff --git a/docs/images/DamithRajapakse.jpg b/docs/images/oldPics/DamithRajapakse.jpg
similarity index 100%
rename from docs/images/DamithRajapakse.jpg
rename to docs/images/oldPics/DamithRajapakse.jpg
diff --git a/docs/images/DeletePersonSdForLogic.png b/docs/images/oldPics/DeletePersonSdForLogic.png
similarity index 100%
rename from docs/images/DeletePersonSdForLogic.png
rename to docs/images/oldPics/DeletePersonSdForLogic.png
diff --git a/docs/images/JoshuaLee.jpg b/docs/images/oldPics/JoshuaLee.jpg
similarity index 100%
rename from docs/images/JoshuaLee.jpg
rename to docs/images/oldPics/JoshuaLee.jpg
diff --git a/docs/images/LogicClassDiagram.png b/docs/images/oldPics/LogicClassDiagram.png
similarity index 100%
rename from docs/images/LogicClassDiagram.png
rename to docs/images/oldPics/LogicClassDiagram.png
diff --git a/docs/images/MartinChoo.jpg b/docs/images/oldPics/MartinChoo.jpg
similarity index 100%
rename from docs/images/MartinChoo.jpg
rename to docs/images/oldPics/MartinChoo.jpg
diff --git a/docs/images/ModelClassDiagram.png b/docs/images/oldPics/ModelClassDiagram.png
similarity index 100%
rename from docs/images/ModelClassDiagram.png
rename to docs/images/oldPics/ModelClassDiagram.png
diff --git a/docs/images/SDforDeletePerson.png b/docs/images/oldPics/SDforDeletePerson.png
similarity index 100%
rename from docs/images/SDforDeletePerson.png
rename to docs/images/oldPics/SDforDeletePerson.png
diff --git a/docs/images/SDforDeletePersonEventHandling.png b/docs/images/oldPics/SDforDeletePersonEventHandling.png
similarity index 100%
rename from docs/images/SDforDeletePersonEventHandling.png
rename to docs/images/oldPics/SDforDeletePersonEventHandling.png
diff --git a/docs/images/StorageClassDiagram.png b/docs/images/oldPics/StorageClassDiagram.png
similarity index 100%
rename from docs/images/StorageClassDiagram.png
rename to docs/images/oldPics/StorageClassDiagram.png
diff --git a/docs/images/UiClassDiagram.png b/docs/images/oldPics/UiClassDiagram.png
similarity index 100%
rename from docs/images/UiClassDiagram.png
rename to docs/images/oldPics/UiClassDiagram.png
diff --git a/docs/images/YouLiang.jpg b/docs/images/oldPics/YouLiang.jpg
similarity index 100%
rename from docs/images/YouLiang.jpg
rename to docs/images/oldPics/YouLiang.jpg
diff --git a/docs/index.html b/docs/index.html
new file mode 100644
index 000000000000..01d3db6c4830
--- /dev/null
+++ b/docs/index.html
@@ -0,0 +1,13 @@
+
+
+ Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam interdum eget justo ut ultrices. Mauris condimentum sollicitudin diam, sed placerat leo consectetur et. Proin porttitor commodo turpis, vitae vehicula purus. In suscipit lacinia augue ac convallis. Donec sed feugiat turpis. Donec iaculis vel ex non viverra. Cras lobortis maximus tellus, ac dictum tellus aliquam quis. Vivamus sed libero suscipit, maximus nisi id, ultricies ante. Aenean a libero lectus. Proin iaculis tincidunt velit nec dictum. Fusce vitae nisi nunc. Maecenas in ultricies metus, nec sollicitudin dolor. In vulputate suscipit quam sed tristique. Aenean at hendrerit massa, fringilla volutpat ex.
+
+Vestibulum nec lobortis quam, a elementum magna. Cras tristique nec nibh in tincidunt. Nulla luctus rutrum neque, non hendrerit mi pulvinar sit amet. Etiam lectus elit, mattis ut interdum ut, pulvinar et sem. Nam efficitur venenatis magna sed rhoncus. Mauris est ex, ullamcorper non cursus vitae, tincidunt ac mi. Morbi blandit sollicitudin metus sit amet feugiat. Aliquam erat volutpat. Nam id imperdiet quam, quis convallis dolor.
+
+Aliquam placerat quam eu tincidunt luctus. Praesent vestibulum nunc semper orci consequat sodales. Pellentesque cursus neque mi, at tempor nulla eleifend eget. Nam finibus maximus leo sit amet sagittis. Aliquam scelerisque facilisis molestie. Pellentesque ullamcorper tincidunt ex in ullamcorper. Donec eget venenatis ex. Mauris sagittis congue ligula, sit amet faucibus dolor elementum eu. Sed et turpis sit amet massa cursus ornare a vitae nisl. Curabitur et erat in neque rhoncus pretium viverra nec augue. Nulla vestibulum est at velit pharetra, sed suscipit felis molestie. Quisque venenatis sagittis mi maximus venenatis. Maecenas turpis odio, luctus vitae mollis vel, rhoncus ac ante.
+
+Nullam posuere pulvinar dolor vitae malesuada. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas tempor facilisis sem, sed vehicula metus efficitur eu. Nullam tristique ac elit in gravida. Phasellus aliquet ut nunc ut scelerisque. Morbi nec arcu diam. Nunc hendrerit lacinia pulvinar. Integer accumsan auctor dolor, at lacinia leo consectetur at. Nam tristique dolor augue, eu pharetra neque dignissim non. Pellentesque bibendum tincidunt leo, feugiat pretium felis facilisis ac. Nulla id gravida velit. Cras ullamcorper neque sit amet magna facilisis tempus. Nulla quis erat eget ante semper consectetur vitae in metus. Etiam quis urna lectus.
+
+Curabitur tempor ullamcorper turpis, vitae scelerisque mauris tristique sit amet. Praesent scelerisque tincidunt orci a ullamcorper. Aliquam convallis eros vitae enim auctor vulputate. Sed dignissim interdum accumsan. Aenean at dui nec mi tempor sagittis sit amet semper nunc. Integer fringilla tortor leo, in consequat nulla consectetur id. Phasellus rutrum sapien velit, sit amet scelerisque augue iaculis sollicitudin. Etiam a finibus metus.
+
+
\ No newline at end of file
diff --git a/libs/A0146130W.md b/libs/A0146130W.md
new file mode 100644
index 000000000000..f7882e9c3111
--- /dev/null
+++ b/libs/A0146130W.md
@@ -0,0 +1,535 @@
+# A0146130W
+###### /src/main/java/seedu/gtd/commons/exceptions/DataConversionException.java
+``` java
+ public DataConversionException(String cause) {
+ super(cause);
+ }
+}
+```
+###### /src/main/java/seedu/gtd/logic/commands/EditCommand.java
+``` java
+ /**
+ * Adds a task to the address book.
+ */
+ public class EditCommand extends Command {
+
+ public static final String COMMAND_WORD = "edit";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ":\n"
+ + "Edits the task identified by the index number used in the last task listing.\n\t"
+ + "Parameters: [INDEX] (must be a positive integer) prefix/[NEW DETAIL]\n\t"
+ + "Example: " + COMMAND_WORD
+ + " 1 p/9";
+
+ public static final String MESSAGE_EDIT_TASK_SUCCESS = "Task updated: %1$s";
+
+ private int targetIndex;
+ private String detailType;
+ private String newDetail;
+
+ public EditCommand(int targetIndex, String detailType, String newDetail) {
+ this.targetIndex = targetIndex;
+ this.detailType = detailType;
+ this.newDetail = newDetail;
+ }
+
+
+ @Override
+ public CommandResult execute() {
+
+ UnmodifiableObservableList lastShownList = model.getFilteredTaskList();
+
+ if (lastShownList.size() < targetIndex) {
+ indicateAttemptToExecuteIncorrectCommand();
+ return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+ }
+
+ ReadOnlyTask toEdit = lastShownList.get(targetIndex);
+ Task taskToUpdate = new Task(toEdit);
+
+ try {
+ taskToUpdate = updateTask(taskToUpdate, detailType, newDetail);
+ } catch (IllegalValueException ive) {
+ return new CommandResult(ive.getMessage());
+ }
+
+ assert model != null;
+ try {
+ model.editTask(targetIndex, taskToUpdate);
+ } catch (TaskNotFoundException e) {
+ assert false : "The target task cannot be missing";
+ }
+ return new CommandResult(String.format(MESSAGE_EDIT_TASK_SUCCESS, taskToUpdate));
+
+ }
+
+ private Task updateTask(Task taskToUpdate, String detailType, String newDetail) throws IllegalValueException {
+ taskToUpdate.edit(detailType, newDetail);
+ return taskToUpdate;
+ }
+
+ }
+```
+###### /src/main/java/seedu/gtd/logic/commands/FindCommand.java
+``` java
+ private final String keywords;
+ private Set keywordSet;
+ private final String cmd;
+
+ public FindCommand(String keywords, Set keywordSet, String cmd) {
+ this.keywords = keywords;
+ this.keywordSet = keywordSet;
+ this.cmd = cmd;
+ }
+
+ private String getMessageForTaskListShownSummaryIfExactPhraseNotFound(int displaySize) {
+ String task_tasks = (displaySize == 1) ? "task" : "tasks";
+
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found. Listing " + displaySize + " " + task_tasks + " containing the keywords entered instead.";
+ return String.format(MESSAGE_IF_EXACT_PHRASE_NOT_FOUND);
+ }
+
+ private String getMessageForTaskListShownSummaryIfExactFieldNotFound(int displaySize) {
+ String task_tasks = (displaySize == 1) ? "task" : "tasks";
+
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found in the specified field type. Listing " + displaySize + " " + task_tasks + " containing the keywords entered instead.";
+ return String.format(MESSAGE_IF_EXACT_PHRASE_NOT_FOUND);
+ }
+
+ @Override
+ public CommandResult execute() {
+ System.out.println("command: " + cmd);
+
+ // search by parameter if specified
+ if (cmd != "nil") {
+ model.updateFilteredTaskList(keywords, cmd);
+ } else {
+ // search by exact name
+ model.updateFilteredTaskList(keywords, keywordSet);
+ }
+ if (!model.getFilteredTaskList().isEmpty()) {
+ return new CommandResult(getMessageForTaskListShownSummary(model.getFilteredTaskList().size()));
+ }
+
+ // search by keywords
+ model.updateFilteredTaskList(keywords, "nil");
+
+ if (!model.getFilteredTaskList().isEmpty()) {
+ if (cmd == "nil") {
+ return new CommandResult(getMessageForTaskListShownSummaryIfExactPhraseNotFound(model.getFilteredTaskList().size()));
+ } else {
+ return new CommandResult(getMessageForTaskListShownSummaryIfExactFieldNotFound(model.getFilteredTaskList().size()));
+ }
+ }
+
+ return new CommandResult(getMessageForTaskListShownSummary(model.getFilteredTaskList().size()));
+ }
+}
+```
+###### /src/main/java/seedu/gtd/logic/commands/UndoCommand.java
+``` java
+
+package seedu.gtd.logic.commands;
+
+/**
+ * Deletes a task identified using it's last displayed index from the address book.
+ */
+public class UndoCommand extends Command {
+
+ public static final String COMMAND_WORD = "undo";
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Un-does the most recent modification of the task list.";
+ public static final String MESSAGE_SUCCESS = "Undo change";
+
+ public UndoCommand() {}
+
+ @Override
+ public CommandResult execute() {
+ model.undoAddressBookChange();
+ return new CommandResult(MESSAGE_SUCCESS);
+ }
+
+}
+```
+###### /src/main/java/seedu/gtd/logic/parser/DateNaturalLanguageProcessor.java
+``` java
+
+/**
+ * Uses natty API: http://natty.joestelmach.com to parse natural language into dates or string
+ */
+public class DateNaturalLanguageProcessor implements NaturalLanguageProcessor {
+
+ private static final com.joestelmach.natty.Parser parser = new com.joestelmach.natty.Parser();
+ private static final String DATE_FORMAT = "dd/MM/yyyy HH:mm";
+
+ @Override
+ public String formatString(String naturalLanguageDate) {
+ List dateGroups = parser.parse(naturalLanguageDate);
+ Date parsedDate;
+ try {
+ parsedDate = refineDateGroupList(dateGroups);
+ } catch (NaturalLanguageException e) {
+ return "";
+ }
+ return formatDateToString(parsedDate);
+ }
+
+ /**
+ * Chooses the first date from a list of dates that Natty has parsed from the natural language string
+ * @throws NaturalLanguageException
+ * */
+ private Date refineDateGroupList(List groups) throws NaturalLanguageException {
+ if(groups.size() == 0) throw new NaturalLanguageException();
+ return groups.get(0).getDates().get(0);
+ }
+
+ private String formatDateToString(Date date) {
+ Format formatter = new SimpleDateFormat(DATE_FORMAT);
+ return formatter.format(date);
+ }
+}
+```
+###### /src/main/java/seedu/gtd/logic/parser/NaturalLanguageProcessor.java
+``` java
+
+package seedu.gtd.logic.parser;
+
+import seedu.gtd.commons.exceptions.DataConversionException;
+
+public interface NaturalLanguageProcessor {
+
+ /** Takes in a string written in natural language and formats it.*/
+ String formatString(String s);
+
+ public static class NaturalLanguageException extends DataConversionException {
+ protected NaturalLanguageException() {
+ super("Natural Language Processor was unable to convert input");
+ }
+ }
+}
+```
+###### /src/main/java/seedu/gtd/logic/parser/Parser.java
+``` java
+
+ private String parseDueDate(String dueDateRaw) {
+ NaturalLanguageProcessor nlp = new DateNaturalLanguageProcessor();
+ return nlp.formatString(dueDateRaw);
+ }
+
+ // remove time on date parsed to improve search results
+ private String removeTimeOnDate(String dueDateRaw) {
+ String[] dateTime = dueDateRaw.split(" ");
+ return dateTime[0];
+ }
+
+```
+###### /src/main/java/seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the edit task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareEdit(String args) {
+
+ final Matcher matcher = EDIT_DATA_ARGS_FORMAT.matcher(args.trim());
+ // Validate arg string format
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, EditCommand.MESSAGE_USAGE));
+ }
+
+ Optional index = Optional.of(Integer.parseInt(matcher.group("targetIndex")));
+ String newDetail = matcher.group("newDetail");
+
+ String detailType = extractDetailType(newDetail);
+ newDetail = prepareNewDetail(detailType, newDetail);
+
+ return new EditCommand(
+ (index.get() - 1),
+ detailType,
+ newDetail
+ );
+ }
+
+ private String extractDetailType(String detailType) {
+ switch(detailType.substring(0, 2)) {
+ case "d/": return "dueDate";
+ case "a/": return "address";
+ case "p/": return "priority";
+ default: return "name";
+ }
+ }
+
+ private String prepareNewDetail(String detailType, String newDetail) {
+
+ if(detailType == "name") {
+ return newDetail;
+ }
+
+ newDetail = newDetail.substring(2);
+ if(detailType == "dueDate") {
+ newDetail = parseDueDate(newDetail);
+ }
+ return newDetail;
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/AddressBook.java
+``` java
+ /**
+ * Edits a task in the address book.
+ * Also checks the updated task's tags and updates {@link #tags} with any new tags found,
+ * and updates the Tag objects in the task to point to those in {@link #tags}.
+ *
+ * @throws UniqueTaskList.TaskNotFoundException if the task was not found.
+ */
+ public void editTask(int index, Task t) throws UniqueTaskList.TaskNotFoundException {
+ syncTagsWithMasterList(t);
+ tasks.edit(index, t);
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/ModelManager.java
+``` java
+ @Override
+ public synchronized void editTask(int targetIndex, Task task) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ System.out.println("editing task..");
+ addressBook.editTask(targetIndex, task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public void clearTaskList() {
+ savePreviousAddressBook();
+ resetData(AddressBook.getEmptyAddressBook());
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Edits an equivalent task from the list.
+ *
+ * @throws TaskNotFoundException if no such task could be found in the list.
+ */
+ public void edit(int targetIndex, Task toEdit) throws TaskNotFoundException {
+ assert toEdit != null;
+ if (invalidIndex(targetIndex)) {
+ throw new TaskNotFoundException();
+ }
+ internalList.set(targetIndex, toEdit);
+ }
+
+ public void done(int targetIndex, Task taskdone) throws TaskNotFoundException {
+ System.out.println("in uniquetasklist");
+ System.out.println(taskdone.getName() + " " + taskdone.getisDone());
+ System.out.println("index at final:" + targetIndex);
+ assert taskdone != null;
+ if (invalidIndex(targetIndex)) {
+ throw new TaskNotFoundException();
+ }
+ System.out.println("marked done in model");
+ internalList.set(targetIndex, taskdone);
+ }
+
+ private boolean invalidIndex(int i) {
+ if(i < 0 || i >= internalList.size()) return true;
+ return false;
+ }
+
+```
+###### /src/test/java/guitests/EditCommandTest.java
+``` java
+
+package guitests;
+
+import org.junit.Test;
+
+import seedu.gtd.testutil.TestTask;
+import seedu.gtd.testutil.TestUtil;
+
+import static org.junit.Assert.assertTrue;
+import static seedu.gtd.logic.commands.EditCommand.MESSAGE_EDIT_TASK_SUCCESS;
+
+public class EditCommandTest extends AddressBookGuiTest {
+
+ @Test
+ public void edit() {
+
+ //edit the priority of the first task
+ TestTask[] currentList = td.getTypicalTasks();
+ int targetIndex = 1;
+ String change = "p/4";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the dueDate of the last in the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ targetIndex = currentList.length;
+ change = "d/2";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the name task from the middle of the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ targetIndex = currentList.length/2;
+ change = "Tutorial 4";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //edit the address task from the middle of the list
+ currentList = TestUtil.editTaskInList(currentList, targetIndex, change, currentList[targetIndex-1]);
+ change = "a/NTU";
+ assertEditSuccess(targetIndex, change, currentList);
+
+ //invalid index
+ commandBox.runCommand("edit " + currentList.length + 1 + " Invalid");
+ assertResultMessage("The task index provided is invalid");
+
+ }
+
+ /**
+ * Runs the edit command to edit the task at specified index and confirms the result is correct.
+ * @param targetIndexOneIndexed e.g. to edit the first task in the list, 1 should be given as the target index.
+ * @param currentList A copy of the current list of tasks (before editing).
+ */
+ private void assertEditSuccess(int targetIndexOneIndexed, String change, final TestTask[] currentList) {
+ TestTask taskToEdit = currentList[targetIndexOneIndexed-1]; //-1 because array uses zero indexing
+ TestTask[] expectedRemainder = TestUtil.editTaskInList(currentList, targetIndexOneIndexed, change, taskToEdit);
+ commandBox.runCommand("edit " + targetIndexOneIndexed + " " + change);
+
+ //confirm the list now contains all previous tasks except the deleted task
+ assertTrue(taskListPanel.isListMatching(expectedRemainder));
+
+ //confirm the result message is correct
+ assertResultMessage(String.format(MESSAGE_EDIT_TASK_SUCCESS, expectedRemainder[targetIndexOneIndexed-1]));
+ }
+
+}
+```
+###### /src/test/java/guitests/UndoCommandTest.java
+``` java
+
+package guitests;
+
+import org.junit.Test;
+
+import seedu.gtd.testutil.TestTask;
+import seedu.gtd.testutil.TestUtil;
+
+import static org.junit.Assert.assertTrue;
+import static seedu.gtd.logic.commands.UndoCommand.MESSAGE_SUCCESS;;
+
+public class UndoCommandTest extends AddressBookGuiTest {
+
+ @Test
+ public void undo() {
+
+ //undo the addition of the first task
+ TestTask[] currentList = td.getTypicalTasks();
+ TestTask[] previousList = currentList;
+ commandBox.runCommand(td.george.getAddCommand());
+ assertUndoSuccess(previousList);
+
+ //undo editing the dueDate of the last task in the list
+ int targetIndex = currentList.length;
+ String change = "d/2";
+ previousList = currentList;
+ commandBox.runCommand("edit " + targetIndex + " " + change);
+ assertUndoSuccess(previousList);
+
+ //undo deleting a task from the middle of the list
+ targetIndex = currentList.length/2;
+ previousList = currentList;
+ commandBox.runCommand("delete " + targetIndex);
+ assertUndoSuccess(previousList);
+
+ //undo clearing list
+ previousList = currentList;
+ commandBox.runCommand("clear");
+ assertUndoSuccess(previousList);
+
+ //undo marking the middle task as done
+ previousList = currentList;
+ commandBox.runCommand("done " + targetIndex);
+ assertUndoSuccess(previousList);
+ }
+
+ /**
+ * Runs the undo command to undo the last change to the task list
+ */
+ private void assertUndoSuccess(final TestTask[] previousList) {
+ commandBox.runCommand("undo");
+
+ //confirm the list now contains all previous tasks except the deleted task
+ assertTrue(taskListPanel.isListMatching(previousList));
+
+ //confirm the result message is correct
+ assertResultMessage(String.format(MESSAGE_SUCCESS));
+ }
+
+}
+```
+###### /src/test/java/seedu/gtd/testutil/TestUtil.java
+``` java
+
+ /**
+ * Edits a task in the array of tasks.
+ * @param tasks A array of tasks.
+ * @param tasksToAdd The tasks that are to be appended behind the original array.
+ * @return The modified array of tasks.
+ * @throws IllegalValueException
+ */
+ public static TestTask[] editTaskInList(final TestTask[] tasks, int index, String change, TestTask taskToEdit) {
+ List listOfTasks = asList(tasks);
+ TestTask taskEditted;
+ try {
+ taskEditted = TestUtilParser.editTask(taskToEdit, change);
+ } catch (IllegalValueException e) {
+ taskEditted = taskToEdit;
+ e.printStackTrace();
+ }
+ listOfTasks.set(index-1, taskEditted);
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+```
+###### /src/test/java/seedu/gtd/testutil/TestUtilParser.java
+``` java
+
+package seedu.gtd.testutil;
+
+import seedu.gtd.commons.exceptions.IllegalValueException;
+import seedu.gtd.logic.parser.DateNaturalLanguageProcessor;
+import seedu.gtd.logic.parser.NaturalLanguageProcessor;
+import seedu.gtd.model.task.Address;
+import seedu.gtd.model.task.DueDate;
+import seedu.gtd.model.task.Name;
+import seedu.gtd.model.task.Priority;
+
+/**
+ * A utility class that parses tasks for test cases.
+ */
+public class TestUtilParser {
+
+ public static TestTask editTask(TestTask task, String change) throws IllegalValueException {
+
+ TestTask newTask = task;
+ String changeWithoutPrefix = change.substring(2);
+ String changePrefix = change.substring(0, 2);
+ System.out.println("From TestUtil Parser: " + changePrefix + " " + changeWithoutPrefix);
+
+ switch(change.substring(0, 2)) {
+ case "d/": newTask = new TestTask(task.getName(), new DueDate(parseDueDate(changeWithoutPrefix)), task.getAddress(), task.getPriority(), task.getTags()); break;
+ case "a/": newTask = new TestTask(task.getName(), task.getDueDate(), new Address(changeWithoutPrefix), task.getPriority(), task.getTags()); break;
+ case "p/": newTask = new TestTask(task.getName(), task.getDueDate(), task.getAddress(), new Priority(changeWithoutPrefix), task.getTags()); break;
+ default: newTask = new TestTask(new Name(change), task.getDueDate(), task.getAddress(), task.getPriority(), task.getTags());
+ }
+ return newTask;
+ }
+
+ public static String parseDueDate(String dueDateRaw) {
+ NaturalLanguageProcessor nlp = new DateNaturalLanguageProcessor();
+ return nlp.formatString(dueDateRaw);
+ }
+}
+```
diff --git a/libs/A0146130WreusedToTest.md b/libs/A0146130WreusedToTest.md
new file mode 100644
index 000000000000..b3041d81ba9b
--- /dev/null
+++ b/libs/A0146130WreusedToTest.md
@@ -0,0 +1,17 @@
+# A0146130WreusedToTest
+###### /src/test/java/seedu/gtd/logic/LogicManagerTest.java
+``` java
+ @Test
+ public void execute_help() throws Exception {
+ assertCommandBehavior("help", HelpCommand.MESSAGE_USAGE+"/n"+HelpCommand.SHOWING_HELP_MESSAGE);
+ assertTrue(helpShown);
+ assertCommandBehavior("help add", AddCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help select", SelectCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help delete", DeleteCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help clear", ClearCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help find", FindCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help list", ListCommand.MESSAGE_USAGE);
+ assertCommandBehavior("help exit", ExitCommand.MESSAGE_USAGE);
+ }
+
+```
diff --git a/libs/addressbooklevel4.md b/libs/addressbooklevel4.md
new file mode 100644
index 000000000000..75c99362d388
--- /dev/null
+++ b/libs/addressbooklevel4.md
@@ -0,0 +1,1905 @@
+# addressbooklevel4
+###### /src/main/java/seedu/gtd/logic/commands/FindCommand.java
+``` java
+ public static final String COMMAND_WORD = "find";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Finds all tasks whose name, date, address, tags and priority contain any of "
+ + "the specified keywords (case-sensitive) and displays them as a list with index numbers.\n"
+ + "To search by one particular field type, use t/ for tags, a/ for address, d/ for duedate and p/ for priority.\n"
+ + "Parameters: [FIELDTYPE] KEYWORD [MORE_KEYWORDS]...\n"
+ + "Example: " + COMMAND_WORD + " cs2103, " + COMMAND_WORD + " d/today";
+
+```
+###### /src/main/java/seedu/gtd/logic/parser/Parser.java
+``` java
+
+ /**
+ * Used for initial separation of command word and args.
+ */
+ private static final Pattern BASIC_COMMAND_FORMAT = Pattern.compile("(?\\S+)(?.*)");
+
+ private static final Pattern TASK_INDEX_ARGS_FORMAT = Pattern.compile("(?.+)");
+
+ private static final Pattern KEYWORDS_ARGS_FORMAT =
+ Pattern.compile("(?\\S+(?:\\s+\\S+)*)"); // one or more keywords separated by whitespace
+
+// private static final Pattern TASK_DATA_ARGS_FORMAT = // '/' forward slashes are reserved for delimiter prefixes
+// Pattern.compile("(?[^/]+)"
+// + " d/(?[^/]+)"
+// + " a/(?[^/]+)"
+// + " p/(?[^/]+)"
+// + "(?(?: t/[^/]+)*)"); // variable number of tags
+
+ private static final Pattern NAME_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile("(?[^/]+) (t|p|a|d|z)/.*");
+
+ private static final Pattern PRIORITY_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* p/(?[^/]+) (t|a|d|z)/.*");
+
+ private static final Pattern ADDRESS_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* a/(?[^/]+) (t|p|d|z)/.*");
+
+ private static final Pattern DUEDATE_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* d/(?[^/]+) (t|a|p|z)/.*");
+
+ private static final Pattern TAGS_TASK_DATA_ARGS_FORMAT =
+ Pattern.compile(".* t/(?[^/]+) (d|a|p|z)/.*");
+
+ private static final Pattern EDIT_DATA_ARGS_FORMAT =
+ Pattern.compile("(?\\S+)"
+ + " (?.*)");
+
+ public Parser() {}
+
+ /**
+ * Parses user input into command for execution.
+ *
+ * @param userInput full user input string
+ * @return the command based on the user input
+ */
+ public Command parseCommand(String userInput) {
+ final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(userInput.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ final String commandWord = matcher.group("commandWord");
+ final String arguments = matcher.group("arguments");
+ switch (commandWord) {
+
+ case AddCommand.COMMAND_WORD:
+ return prepareAdd(arguments);
+
+ case EditCommand.COMMAND_WORD:
+ return prepareEdit(arguments);
+
+ case SelectCommand.COMMAND_WORD:
+ return prepareSelect(arguments);
+
+ case DeleteCommand.COMMAND_WORD:
+ return prepareDelete(arguments);
+
+ case DoneCommand.COMMAND_WORD:
+ return prepareDone(arguments);
+
+ case ClearCommand.COMMAND_WORD:
+ return new ClearCommand();
+
+ case FindCommand.COMMAND_WORD:
+ return prepareFind(arguments);
+
+ case ListCommand.COMMAND_WORD:
+ return prepareList(arguments);
+
+ case ExitCommand.COMMAND_WORD:
+ return new ExitCommand();
+
+ case HelpCommand.COMMAND_WORD:
+ return prepareHelp(arguments);
+
+ case UndoCommand.COMMAND_WORD:
+ return new UndoCommand();
+
+ default:
+ return new IncorrectCommand(MESSAGE_UNKNOWN_COMMAND);
+ }
+ }
+
+ /**
+ * Parses arguments in the context of the add task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareAdd(String args){
+ String preprocessedArg = appendEnd(args.trim());
+
+ final Matcher nameMatcher = NAME_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher dueDateMatcher = DUEDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher addressMatcher = ADDRESS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher priorityMatcher = PRIORITY_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+ final Matcher tagsMatcher = TAGS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArg);
+
+ String nameToAdd = checkEmptyAndAddDefault(nameMatcher, "name", "none");
+ String dueDateToAdd = checkEmptyAndAddDefault(dueDateMatcher, "dueDate", "none");
+ String addressToAdd = checkEmptyAndAddDefault(addressMatcher, "address", "none");
+ String priorityToAdd = checkEmptyAndAddDefault(priorityMatcher, "priority", "1");
+// String tagsToAdd = checkEmptyAndAddDefault(tagsMatcher, "tagsArgument", "");
+
+ // format date if due date is specified
+ if (dueDateMatcher.matches()) {
+ dueDateToAdd = parseDueDate(dueDateToAdd);
+ }
+
+ Set tagsProcessed = Collections.emptySet();
+
+ if (tagsMatcher.matches()) {
+ tagsProcessed = getTagsFromArgs(tagsMatcher.group("tagArguments"));
+ }
+
+ // Validate arg string format
+ if (!nameMatcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE));
+ }
+
+ try {
+ return new AddCommand(
+ nameToAdd,
+ dueDateToAdd,
+ addressToAdd,
+ priorityToAdd,
+ tagsProcessed
+ );
+ } catch (IllegalValueException ive) {
+ return new IncorrectCommand(ive.getMessage());
+ }
+ }
+
+ private String appendEnd(String args) {
+ return args + " z/";
+ }
+
+ private String checkEmptyAndAddDefault(Matcher matcher, String groupName, String defaultValue) {
+ if (matcher.matches()) {
+ return matcher.group(groupName);
+ } else {
+ return defaultValue;
+ }
+ }
+
+```
+###### /src/main/java/seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Extracts the new task's tags from the add command's tag arguments string.
+ * Merges duplicate tag strings.
+ */
+ private static Set getTagsFromArgs(String tagArguments) {
+ // no tags
+ if (tagArguments.isEmpty()) {
+ return Collections.emptySet();
+ }
+ // replace first delimiter prefix, then split
+ final Collection tagStrings = Arrays.asList(tagArguments.split(" "));
+ return new HashSet<>(tagStrings);
+ }
+
+```
+###### /src/main/java/seedu/gtd/logic/parser/Parser.java
+``` java
+ /**
+ * Parses arguments in the context of the delete task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareDelete(String args) {
+
+ Optional index = parseIndex(args);
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE));
+ }
+
+ return new DeleteCommand(index.get());
+ }
+
+ private Command prepareDone(String args) {
+
+ Optional index = parseIndex(args);
+ System.out.println("index at preparedone:" + index.get());
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, DoneCommand.MESSAGE_USAGE));
+ }
+
+ return new DoneCommand(index.get());
+ }
+
+ /**
+ * Parses arguments in the context of the select task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareSelect(String args) {
+ Optional index = parseIndex(args);
+ if(!index.isPresent()){
+ return new IncorrectCommand(
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, SelectCommand.MESSAGE_USAGE));
+ }
+
+ return new SelectCommand(index.get());
+ }
+
+ /**
+ * Returns the specified index in the {@code command} IF a positive unsigned integer is given as the index.
+ * Returns an {@code Optional.empty()} otherwise.
+ */
+ private Optional parseIndex(String command) {
+ final Matcher matcher = TASK_INDEX_ARGS_FORMAT.matcher(command.trim());
+ if (!matcher.matches()) {
+ return Optional.empty();
+ }
+
+ String index = matcher.group("targetIndex");
+ if(!StringUtil.isUnsignedInteger(index)){
+ return Optional.empty();
+ }
+ return Optional.of(Integer.parseInt(index));
+
+ }
+
+ /**
+ * Parses arguments in the context of the find task command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareFind(String args) {
+
+ // check if parameters are specified and pass specified field to FindCommand
+
+ String preprocessedArgs = " " + appendEnd(args.trim());
+ final Matcher addressMatcher = ADDRESS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher priorityMatcher = PRIORITY_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher dueDateMatcher = DUEDATE_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+ final Matcher tagsMatcher = TAGS_TASK_DATA_ARGS_FORMAT.matcher(preprocessedArgs);
+
+ Set defaultSet = new HashSet();
+
+ if (addressMatcher.matches()) {
+ String addressToBeFound = addressMatcher.group("address");
+ return new FindCommand(addressToBeFound, defaultSet,"address");
+ }
+ if (priorityMatcher.matches()) {
+ String priorityToBeFound = priorityMatcher.group("priority");
+ return new FindCommand(priorityToBeFound, defaultSet, "priority");
+ }
+ if (dueDateMatcher.matches()) {
+ String dueDateToBeFound = dueDateMatcher.group("dueDate");
+ String parsedDueDateToBeFound = removeTimeOnDate(parseDueDate(dueDateToBeFound));
+ return new FindCommand(parsedDueDateToBeFound, defaultSet, "dueDate");
+ }
+ if (tagsMatcher.matches()) {
+ String tagsToBeFound = tagsMatcher.group("tagArguments");
+ return new FindCommand(tagsToBeFound, defaultSet,"tagArguments");
+ }
+
+ // free-form search by keywords
+
+ final Matcher matcher = KEYWORDS_ARGS_FORMAT.matcher(args.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+ FindCommand.MESSAGE_USAGE));
+ }
+
+ // keywords delimited by whitespace
+ final String[] splitKeywords = matcher.group("keywords").split("\\s+");
+ final Set keywordSet = new HashSet<>(Arrays.asList(splitKeywords));
+
+ final String keywords = matcher.group("keywords");
+ return new FindCommand(keywords, keywordSet, "nil");
+ }
+
+private Command prepareList(String args) {
+
+ // check if parameters are specified and pass specified field to FindCommand
+
+ //String preprocessedArgs = " " + appendEnd(args.trim());
+ return new ListCommand(args);
+}
+
+ /**
+ * Parses arguments in the context of the help command.
+ *
+ * @param args full command args string
+ * @return the prepared command
+ */
+ private Command prepareHelp(String args) {
+ //if no argument
+ if (args.equals("")) {
+ args="help";
+ }
+
+ final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(args.trim());
+ if (!matcher.matches()) {
+ return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ final String commandWord = matcher.group("commandWord");
+ return new HelpCommand(commandWord);
+ }
+}
+```
+###### /src/main/java/seedu/gtd/MainApp.java
+``` java
+public class MainApp extends Application {
+ private static final Logger logger = LogsCenter.getLogger(MainApp.class);
+
+ public static final Version VERSION = new Version(1, 0, 0, true);
+
+ protected Ui ui;
+ protected Logic logic;
+ protected Storage storage;
+ protected Model model;
+ protected Config config;
+ protected UserPrefs userPrefs;
+
+ public MainApp() {}
+
+ @Override
+ public void init() throws Exception {
+ logger.info("=============================[ Initializing TaskList ]===========================");
+ super.init();
+
+ config = initConfig(getApplicationParameter("config"));
+ storage = new StorageManager(config.getAddressBookFilePath(), config.getUserPrefsFilePath());
+
+ userPrefs = initPrefs(config);
+
+ initLogging(config);
+
+ model = initModelManager(storage, userPrefs);
+
+ logic = new LogicManager(model, storage);
+
+ ui = new UiManager(logic, config, userPrefs);
+
+ initEventsCenter();
+ }
+
+ private String getApplicationParameter(String parameterName){
+ Map applicationParameters = getParameters().getNamed();
+ return applicationParameters.get(parameterName);
+ }
+
+ private Model initModelManager(Storage storage, UserPrefs userPrefs) {
+ Optional addressBookOptional;
+ ReadOnlyAddressBook initialData;
+ try {
+ addressBookOptional = storage.readAddressBook();
+ if(!addressBookOptional.isPresent()){
+ logger.info("Data file not found. Will be starting with an empty TaskList");
+ }
+ initialData = addressBookOptional.orElse(new AddressBook());
+ } catch (DataConversionException e) {
+ logger.warning("Data file not in the correct format. Will be starting with an empty TaskList");
+ initialData = new AddressBook();
+ } catch (IOException e) {
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
+ initialData = new AddressBook();
+ }
+
+ return new ModelManager(initialData, userPrefs);
+ }
+
+ private void initLogging(Config config) {
+ LogsCenter.init(config);
+ }
+
+ protected Config initConfig(String configFilePath) {
+ Config initializedConfig;
+ String configFilePathUsed;
+
+ configFilePathUsed = Config.DEFAULT_CONFIG_FILE;
+
+ if(configFilePath != null) {
+ logger.info("Custom Config file specified " + configFilePath);
+ configFilePathUsed = configFilePath;
+ }
+
+ logger.info("Using config file : " + configFilePathUsed);
+
+ try {
+ Optional configOptional = ConfigUtil.readConfig(configFilePathUsed);
+ initializedConfig = configOptional.orElse(new Config());
+ } catch (DataConversionException e) {
+ logger.warning("Config file at " + configFilePathUsed + " is not in the correct format. " +
+ "Using default config properties");
+ initializedConfig = new Config();
+ }
+
+ //Update config file in case it was missing to begin with or there are new/unused fields
+ try {
+ ConfigUtil.saveConfig(initializedConfig, configFilePathUsed);
+ } catch (IOException e) {
+ logger.warning("Failed to save config file : " + StringUtil.getDetails(e));
+ }
+ return initializedConfig;
+ }
+
+ protected UserPrefs initPrefs(Config config) {
+ assert config != null;
+
+ String prefsFilePath = config.getUserPrefsFilePath();
+ logger.info("Using prefs file : " + prefsFilePath);
+
+ UserPrefs initializedPrefs;
+ try {
+ Optional prefsOptional = storage.readUserPrefs();
+ initializedPrefs = prefsOptional.orElse(new UserPrefs());
+ } catch (DataConversionException e) {
+ logger.warning("UserPrefs file at " + prefsFilePath + " is not in the correct format. " +
+ "Using default user prefs");
+ initializedPrefs = new UserPrefs();
+ } catch (IOException e) {
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
+ initializedPrefs = new UserPrefs();
+ }
+
+ //Update prefs file in case it was missing to begin with or there are new/unused fields
+ try {
+ storage.saveUserPrefs(initializedPrefs);
+ } catch (IOException e) {
+ logger.warning("Failed to save config file : " + StringUtil.getDetails(e));
+ }
+
+ return initializedPrefs;
+ }
+
+ private void initEventsCenter() {
+ EventsCenter.getInstance().registerHandler(this);
+ }
+
+ @Override
+ public void start(Stage primaryStage) {
+ logger.info("Starting TaskList " + MainApp.VERSION);
+ ui.start(primaryStage);
+ }
+
+ @Override
+ public void stop() {
+ logger.info("============================ [ Stopping Task List ] =============================");
+ ui.stop();
+ try {
+ storage.saveUserPrefs(userPrefs);
+ } catch (IOException e) {
+ logger.severe("Failed to save preferences " + StringUtil.getDetails(e));
+ }
+ Platform.exit();
+ System.exit(0);
+ }
+
+ @Subscribe
+ public void handleExitAppRequestEvent(ExitAppRequestEvent event) {
+ logger.info(LogsCenter.getEventHandlingLogMessage(event));
+ this.stop();
+ }
+
+ public static void main(String[] args) {
+ launch(args);
+ }
+}
+```
+###### /src/main/java/seedu/gtd/model/AddressBook.java
+``` java
+ private final UniqueTaskList tasks;
+ private final UniqueTagList tags;
+
+ {
+ tasks = new UniqueTaskList();
+ tags = new UniqueTagList();
+ }
+
+ public AddressBook() {}
+
+ /**
+ * Tasks and Tags are copied into this addressbook
+ */
+ public AddressBook(ReadOnlyAddressBook toBeCopied) {
+ this(toBeCopied.getUniqueTaskList(), toBeCopied.getUniqueTagList());
+ System.out.println("start with first method");
+ }
+
+ /**
+ * Tasks and Tags are copied into this addressbook
+ */
+ public AddressBook(UniqueTaskList tasks, UniqueTagList tags) {
+ resetData(tasks.getInternalList(), tags.getInternalList());
+ System.out.println("start with second method");
+ }
+
+ public static ReadOnlyAddressBook getEmptyAddressBook() {
+ return new AddressBook();
+ }
+
+//// list overwrite operations
+
+ public ObservableList getTasks() {
+ return tasks.getInternalList();
+ }
+
+ public void setTasks(List tasks) {
+ this.tasks.getInternalList().setAll(tasks);
+ }
+
+ public void setTags(Collection tags) {
+ this.tags.getInternalList().setAll(tags);
+ }
+
+ public void resetData(Collection newTasks, Collection newTags) {
+ setTasks(newTasks.stream().map(Task::new).collect(Collectors.toList()));
+ setTags(newTags);
+ }
+
+ public void resetData(ReadOnlyAddressBook newData) {
+ resetData(newData.getTaskList(), newData.getTagList());
+ }
+
+//// task-level operations
+
+ /**
+ * Adds a task to the address book.
+ * Also checks the new task's tags and updates {@link #tags} with any new tags found,
+ * and updates the Tag objects in the task to point to those in {@link #tags}.
+ *
+ * @throws UniqueTaskList.DuplicateTaskException if an equivalent task already exists.
+ */
+ public void addTask(Task t) throws UniqueTaskList.DuplicateTaskException {
+ syncTagsWithMasterList(t);
+ tasks.add(t);
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/AddressBook.java
+``` java
+ /**
+ * Ensures that every tag in this task:
+ * - exists in the master list {@link #tags}
+ * - points to a Tag object in the master list
+ */
+ private void syncTagsWithMasterList(Task t) {
+ final UniqueTagList taskTags = t.getTags();
+ tags.mergeFrom(taskTags);
+
+ // Create map with values = tag object references in the master list
+ final Map masterTagObjects = new HashMap<>();
+ for (Tag tag : tags) {
+ masterTagObjects.put(tag, tag);
+ }
+
+ // Rebuild the list of task tags using references from the master list
+ final Set commonTagReferences = new HashSet<>();
+ for (Tag tag : taskTags) {
+ commonTagReferences.add(masterTagObjects.get(tag));
+ }
+ t.setTags(new UniqueTagList(commonTagReferences));
+ }
+
+ public boolean removeTask(ReadOnlyTask key) throws UniqueTaskList.TaskNotFoundException {
+ if (tasks.remove(key)) {
+ return true;
+ } else {
+ throw new UniqueTaskList.TaskNotFoundException();
+ }
+ }
+
+ public void doneTask(int index, Task target) throws TaskNotFoundException {
+ System.out.println("in addressbook");
+ tasks.done(index, target);
+ }
+
+//// tag-level operations
+
+ public void addTag(Tag t) throws UniqueTagList.DuplicateTagException {
+ tags.add(t);
+ }
+
+//// util methods
+
+ @Override
+ public String toString() {
+ return tasks.getInternalList().size() + " tasks, " + tags.getInternalList().size() + " tags";
+ // TODO: refine later
+ }
+
+ @Override
+ public List getTaskList() {
+ return Collections.unmodifiableList(tasks.getInternalList());
+ }
+
+ @Override
+ public List getTagList() {
+ return Collections.unmodifiableList(tags.getInternalList());
+ }
+
+ @Override
+ public UniqueTaskList getUniqueTaskList() {
+ return this.tasks;
+ }
+
+ @Override
+ public UniqueTagList getUniqueTagList() {
+ return this.tags;
+ }
+
+
+ @Override
+ public boolean equals(Object other) {
+ return other == this // short circuit if same object
+ || (other instanceof AddressBook // instanceof handles nulls
+ && this.tasks.equals(((AddressBook) other).tasks)
+ && this.tags.equals(((AddressBook) other).tags));
+ }
+
+ @Override
+ public int hashCode() {
+ // use this method for custom fields hashing instead of implementing your own
+ return Objects.hash(tasks, tags);
+ }
+}
+```
+###### /src/main/java/seedu/gtd/model/ModelManager.java
+``` java
+
+ private static final Logger logger = LogsCenter.getLogger(ModelManager.class);
+
+ private AddressBook addressBook;
+ private final FilteredList filteredTasks;
+ private AddressBook previousAddressBook;
+
+ /**
+ * Initializes a ModelManager with the given AddressBook
+ * AddressBook and its variables should not be null
+ */
+ public ModelManager(AddressBook src, UserPrefs userPrefs) {
+ super();
+ assert src != null;
+ assert userPrefs != null;
+
+ logger.fine("Initializing with address book: " + src + " and user prefs " + userPrefs);
+
+ addressBook = new AddressBook(src);
+ filteredTasks = new FilteredList<>(addressBook.getTasks());
+ previousAddressBook = new AddressBook(addressBook);
+ }
+
+ public ModelManager() {
+ this(new AddressBook(), new UserPrefs());
+ }
+
+ public ModelManager(ReadOnlyAddressBook initialData, UserPrefs userPrefs) {
+ addressBook = new AddressBook(initialData);
+ filteredTasks = new FilteredList<>(addressBook.getTasks());
+ previousAddressBook = new AddressBook(addressBook);
+ }
+
+ private void resetData(ReadOnlyAddressBook newData) {
+ addressBook.resetData(newData);
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public ReadOnlyAddressBook getAddressBook() {
+ return addressBook;
+ }
+
+ /** Raises an event to indicate the model has changed */
+ private void indicateAddressBookChanged() {
+ raise(new AddressBookChangedEvent(addressBook));
+ }
+
+ private void savePreviousAddressBook() {
+ previousAddressBook = new AddressBook(addressBook);
+ }
+
+ @Override
+ public void undoAddressBookChange() {
+ resetData(previousAddressBook);
+ }
+
+ @Override
+ public synchronized void deleteTask(ReadOnlyTask target) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ addressBook.removeTask(target);
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public synchronized void doneTask(int targetIndex, Task task) throws TaskNotFoundException {
+ savePreviousAddressBook();
+ System.out.println("in model manager");
+ addressBook.doneTask(targetIndex, task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+ @Override
+ public synchronized void addTask(Task task) throws UniqueTaskList.DuplicateTaskException {
+ savePreviousAddressBook();
+ addressBook.addTask(task);
+ updateFilteredListToShowAll();
+ indicateAddressBookChanged();
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/ModelManager.java
+``` java
+ //=========== Filtered Task List Accessors ===============================================================
+
+ @Override
+ public UnmodifiableObservableList getFilteredTaskList() {
+ return new UnmodifiableObservableList<>(filteredTasks);
+ }
+
+ @Override
+ public void updateFilteredListToShowAll() {
+ updateFilteredListToShowAll(new PredicateExpression(new RemoveDoneQualifier()));
+ System.out.println("show all");
+ }
+
+ private void updateFilteredListToShowAll(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ @Override
+ public void updateFilteredListToShowRemoved() {
+ updateFilteredListToShowRemoved(new PredicateExpression(new DoneQualifier()));
+ System.out.println("show done list");
+ }
+
+ private void updateFilteredListToShowRemoved(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ @Override
+ public void updateFilteredTaskList(Set keywordSet) {
+ updateFilteredTaskList(new PredicateExpression(new NameQualifier(keywordSet)));
+ }
+
+ @Override
+ public void updateFilteredTaskList(String keywords, Set keywordSet){
+ updateFilteredTaskList(new PredicateExpression(new orderedNameQualifier(keywords, keywordSet)));
+ }
+
+ @Override
+ public void updateFilteredTaskList(String keywords, String cmd) {
+ updateFilteredTaskList(new PredicateExpression(new otherFieldsQualifier(keywords, cmd)));
+ }
+
+ private void updateFilteredTaskList(Expression expression) {
+ filteredTasks.setPredicate(expression::satisfies);
+ }
+
+ //========== Inner classes/interfaces used for filtering ==================================================
+
+ interface Expression {
+ boolean satisfies(ReadOnlyTask task);
+ String toString();
+ }
+
+ private class PredicateExpression implements Expression {
+
+ private final Qualifier qualifier;
+
+ PredicateExpression(Qualifier qualifier) {
+ this.qualifier = qualifier;
+ }
+
+ @Override
+ public boolean satisfies(ReadOnlyTask task) {
+ return qualifier.run(task);
+ }
+
+ @Override
+ public String toString() {
+ return qualifier.toString();
+ }
+ }
+
+ interface Qualifier {
+ boolean run(ReadOnlyTask task);
+ String toString();
+ }
+
+ private class NameQualifier implements Qualifier {
+ protected Set keywordSet;
+
+ NameQualifier(Set keywordSet) {
+ this.keywordSet = keywordSet;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ return keywordSet.stream()
+ .filter(keyword -> StringUtil.containsIgnoreCase(task.getName().fullName, keyword))
+ .findAny()
+ .isPresent();
+ }
+
+ @Override
+ public String toString() {
+ return "name=" + String.join(", ", keywordSet);
+ }
+ }
+
+ private class otherFieldsQualifier implements Qualifier {
+ protected String nameKeyWords;
+ protected String cmd;
+
+ otherFieldsQualifier(String keywords, String cmd) {
+ this.nameKeyWords = keywords;
+ this.cmd = cmd;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ if (cmd == "address") {
+ System.out.println("finding address..");
+ String address = task.getAddress().toString().toLowerCase();
+ boolean addressMatch = address.contains(nameKeyWords.toLowerCase());
+ return addressMatch;
+ } else if (cmd == "priority") {
+ System.out.println("finding priority..");
+ String priority = task.getPriority().toString();
+ boolean priorityMatch = priority.contains(nameKeyWords);
+ return priorityMatch;
+ } else if (cmd == "dueDate") {
+ System.out.println("finding dueDate..");
+ String dueDate = task.getDueDate().toString();
+ boolean dueDateMatch = dueDate.contains(nameKeyWords);
+ return dueDateMatch;
+ } else if (cmd == "tagArguments") {
+ System.out.println("finding tags.. ");
+ UniqueTagList tagsList = task.getTags();
+ boolean tagsMatch = tagsList.containSearch(nameKeyWords.toLowerCase());
+ return tagsMatch;
+ }
+
+ // cmd == "nil"
+
+ String taskFullNameLowerCase = task.getName().fullName.toLowerCase();
+ String priority = task.getPriority().toString();
+ String address = task.getAddress().toString().toLowerCase();
+ String dueDate = task.getDueDate().toString();
+ UniqueTagList tagsList = task.getTags();
+
+ boolean nameMatch = taskFullNameLowerCase.contains(nameKeyWords.toLowerCase());
+ boolean addressMatch = address.contains(nameKeyWords.toLowerCase());
+ boolean priorityMatch = priority.contains(nameKeyWords);
+ boolean dueDateMatch = dueDate.contains(nameKeyWords);
+ boolean tagsMatch = tagsList.containSearch(nameKeyWords.toLowerCase());
+ boolean eachWordMatch = false;
+
+ String[] eachWord = nameKeyWords.split(" ");
+ for (String word : eachWord) {
+ System.out.println("each: " + word);
+ eachWordMatch = eachWordMatch || taskFullNameLowerCase.contains(word.toLowerCase());
+ }
+
+ return eachWordMatch || nameMatch || addressMatch || priorityMatch || dueDateMatch || tagsMatch;
+ }
+ }
+
+ private class orderedNameQualifier extends NameQualifier implements Qualifier {
+ private String nameKeyWords;
+
+ orderedNameQualifier(String keywords, Set keywordSet) {
+ super(keywordSet);
+ this.nameKeyWords = keywords;
+ }
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ String taskFullNameLowerCase = task.getName().fullName.toLowerCase();
+ boolean nameMatch = taskFullNameLowerCase.contains(nameKeyWords.toLowerCase());
+
+ boolean eachWordMatch = keywordSet.stream()
+ .filter(keyword -> StringUtil.containsIgnoreCase(task.getName().fullName, keyword))
+ .findAny()
+ .isPresent();
+ return eachWordMatch && nameMatch;
+ }
+ }
+
+ // to check and return a list of tasks that are already done
+ private class DoneQualifier implements Qualifier {
+
+ DoneQualifier() {}
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ return task.getisDone();
+ }
+ }
+
+ // default display tasks that are not yet done
+ private class RemoveDoneQualifier implements Qualifier {
+
+ RemoveDoneQualifier() {}
+
+ @Override
+ public boolean run(ReadOnlyTask task) {
+ System.out.println(task.getName());
+ return !task.getisDone();
+ }
+ }
+}
+```
+###### /src/main/java/seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Signals that an operation would have violated the 'no duplicates' property of the list.
+ */
+ public static class DuplicateTaskException extends DuplicateDataException {
+ protected DuplicateTaskException() {
+ super("Operation would result in duplicate tasks");
+ }
+ }
+
+ /**
+ * Signals that an operation targeting a specified task in the list would fail because
+ * there is no such matching task in the list.
+ */
+ public static class TaskNotFoundException extends Exception {}
+
+ private final ObservableList internalList = FXCollections.observableArrayList();
+
+ /**
+ * Constructs empty TaskList.
+ */
+ public UniqueTaskList() {}
+
+ /**
+ * Returns true if the list contains an equivalent task as the given argument.
+ */
+ public boolean contains(ReadOnlyTask toCheck) {
+ assert toCheck != null;
+ return internalList.contains(toCheck);
+ }
+
+ /**
+ * Adds a task to the list.
+ *
+ * @throws DuplicateTaskException if the task to add is a duplicate of an existing task in the list.
+ */
+ public void add(Task toAdd) throws DuplicateTaskException {
+ assert toAdd != null;
+ if (contains(toAdd)) {
+ throw new DuplicateTaskException();
+ }
+ internalList.add(toAdd);
+ }
+
+```
+###### /src/main/java/seedu/gtd/model/task/UniqueTaskList.java
+``` java
+ /**
+ * Removes the equivalent task from the list.
+ *
+ * @throws TaskNotFoundException if no such task could be found in the list.
+ */
+ public boolean remove(ReadOnlyTask toRemove) throws TaskNotFoundException {
+ assert toRemove != null;
+ final boolean taskFoundAndDeleted = internalList.remove(toRemove);
+ if (!taskFoundAndDeleted) {
+ throw new TaskNotFoundException();
+ }
+ return taskFoundAndDeleted;
+ }
+
+ public ObservableList getInternalList() {
+ return internalList;
+ }
+
+ @Override
+ public Iterator iterator() {
+ return internalList.iterator();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other == this // short circuit if same object
+ || (other instanceof UniqueTaskList // instanceof handles nulls
+ && this.internalList.equals(
+ ((UniqueTaskList) other).internalList));
+ }
+
+ @Override
+ public int hashCode() {
+ return internalList.hashCode();
+ }
+}
+```
+###### /src/test/java/seedu/gtd/logic/LogicManagerTest.java
+``` java
+
+ /**
+ * See https://github.com/junit-team/junit4/wiki/rules#temporaryfolder-rule
+ */
+ @Rule
+ public TemporaryFolder saveFolder = new TemporaryFolder();
+
+ private Model model;
+ private Logic logic;
+
+ //These are for checking the correctness of the events raised
+ private ReadOnlyAddressBook latestSavedAddressBook;
+ private boolean helpShown;
+ private int targetedJumpIndex;
+
+ @Subscribe
+ private void handleLocalModelChangedEvent(AddressBookChangedEvent abce) {
+ latestSavedAddressBook = new AddressBook(abce.data);
+ }
+
+ @Subscribe
+ private void handleShowHelpRequestEvent(ShowHelpRequestEvent she) {
+ helpShown = true;
+ }
+
+ @Subscribe
+ private void handleJumpToListRequestEvent(JumpToListRequestEvent je) {
+ targetedJumpIndex = je.targetIndex;
+ }
+
+ @Before
+ public void setup() {
+ model = new ModelManager();
+ String tempAddressBookFile = saveFolder.getRoot().getPath() + "TempAddressBook.xml";
+ String tempPreferencesFile = saveFolder.getRoot().getPath() + "TempPreferences.json";
+ logic = new LogicManager(model, new StorageManager(tempAddressBookFile, tempPreferencesFile));
+ EventsCenter.getInstance().registerHandler(this);
+
+ latestSavedAddressBook = new AddressBook(model.getAddressBook()); // last saved assumed to be up to date before.
+ helpShown = false;
+ targetedJumpIndex = -1; // non yet
+ }
+
+ @After
+ public void teardown() {
+ EventsCenter.clearSubscribers();
+ }
+
+ @Test
+ public void execute_invalid() throws Exception {
+ String invalidCommand = " ";
+ assertCommandBehavior(invalidCommand,
+ String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+ }
+
+ /**
+ * Executes the command and confirms that the result message is correct.
+ * Both the 'address book' and the 'last shown list' are expected to be empty.
+ * @see #assertCommandBehavior(String, String, ReadOnlyAddressBook, List)
+ */
+ private void assertCommandBehavior(String inputCommand, String expectedMessage) throws Exception {
+ assertCommandBehavior(inputCommand, expectedMessage, new AddressBook(), Collections.emptyList());
+ }
+
+ /**
+ * Executes the command and confirms that the result message is correct and
+ * also confirms that the following three parts of the LogicManager object's state are as expected:
+ * - the internal address book data are same as those in the {@code expectedAddressBook}
+ * - the backing list shown by UI matches the {@code shownList}
+ * - {@code expectedAddressBook} was saved to the storage file.
+ */
+ private void assertCommandBehavior(String inputCommand, String expectedMessage,
+ ReadOnlyAddressBook expectedAddressBook,
+ List expectedShownList) throws Exception {
+
+ //Execute the command
+ CommandResult result = logic.execute(inputCommand);
+ System.out.println(inputCommand);
+
+ //Confirm the ui display elements should contain the right data
+ System.out.println(result.feedbackToUser);
+ System.out.println(expectedMessage);
+ assertEquals(expectedMessage, result.feedbackToUser);
+ System.out.println("correct message");
+ assertEquals(expectedShownList, model.getFilteredTaskList());
+ System.out.println("correct data in UI");
+
+ //Confirm the state of data (saved and in-memory) is as expected
+ assertEquals(expectedAddressBook, model.getAddressBook());
+ assertEquals(expectedAddressBook, latestSavedAddressBook);
+ }
+
+
+ @Test
+ public void execute_unknownCommandWord() throws Exception {
+ String unknownCommand = "uicfhmowqewca";
+ assertCommandBehavior(unknownCommand, MESSAGE_UNKNOWN_COMMAND);
+ }
+
+```
+###### /src/test/java/seedu/gtd/logic/LogicManagerTest.java
+``` java
+ @Test
+ public void execute_exit() throws Exception {
+ assertCommandBehavior("exit", ExitCommand.MESSAGE_EXIT_ACKNOWLEDGEMENT);
+ }
+
+ @Test
+ public void execute_clear() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ model.addTask(helper.generateTask(1));
+ model.addTask(helper.generateTask(2));
+ model.addTask(helper.generateTask(3));
+
+ assertCommandBehavior("clear", ClearCommand.MESSAGE_SUCCESS, new AddressBook(), Collections.emptyList());
+ }
+
+ @Test
+ public void execute_add_invalidArgsFormat() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE);
+ assertCommandBehavior(
+ "add ", expectedMessage);
+ }
+
+
+ @Test
+ public void execute_add_invalidTaskData() throws Exception {
+ assertCommandBehavior(
+ "add []\\[;] d/12345 a/valid, address p/1", Name.MESSAGE_NAME_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/not_numbers a/valid, address p/2", DueDate.MESSAGE_DUEDATE_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/12345 a/valid, address p/not_priority_numbers", Priority.MESSAGE_PRIORITY_CONSTRAINTS);
+ assertCommandBehavior(
+ "add Valid Name d/12345 a/valid, address p/5 t/invalid_-[.tag", Tag.MESSAGE_TAG_CONSTRAINTS);
+
+ }
+
+ @Test
+ public void execute_add_successful() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.adam();
+ Task dateChanged = helper.adamChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(dateChanged);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateAddCommand(toBeAdded),
+ String.format(AddCommand.MESSAGE_SUCCESS, dateChanged),
+ expectedAB,
+ expectedAB.getTaskList());
+
+ }
+
+ @Test
+ public void execute_add_optional_successful() throws Exception {
+
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task intendedResult = helper.optionalAddressDateChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(intendedResult);
+ String optionalAddressCmd = "add clean room d/noon p/3 t/tag1";
+
+ assertCommandBehavior(optionalAddressCmd,
+ String.format(AddCommand.MESSAGE_SUCCESS, intendedResult),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+ @Test
+ public void execute_addDuplicate_notAllowed() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeAdded = helper.adam();
+ Task changedDate = helper.adamChanged();
+ AddressBook expectedAB = new AddressBook();
+ expectedAB.addTask(changedDate);
+
+ // setup starting state
+ model.addTask(changedDate); // task already in internal address book
+
+ // execute command and verify result
+ assertCommandBehavior(
+ helper.generateAddCommand(toBeAdded),
+ AddCommand.MESSAGE_DUPLICATE_TASK,
+ expectedAB,
+ expectedAB.getTaskList());
+
+ }
+
+ /*
+ @Test
+ public void execute_edit_successful() throws Exception {
+ // setup expectations
+ TestDataHelper helper = new TestDataHelper();
+ Task toBeEdited = helper.adam();
+ AddressBook expectedAB = helper.generateAddressBook(2);
+ expectedAB.editTask(1, toBeEdited);
+
+ // execute command and verify result
+ assertCommandBehavior(helper.generateEditCommand(toBeEdited),
+ String.format(EditCommand.MESSAGE_EDIT_TASK_SUCCESS, toBeEdited),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+ */
+
+
+ @Test
+ public void execute_list_showsAllTasks() throws Exception {
+ // prepare expectations
+ TestDataHelper helper = new TestDataHelper();
+ AddressBook expectedAB = helper.generateAddressBook(2);
+ List expectedList = expectedAB.getTaskList();
+
+ // prepare address book state
+ helper.addToModel(model, 2);
+
+ assertCommandBehavior("list",
+ ListCommand.MESSAGE_SUCCESS,
+ expectedAB,
+ expectedList);
+ }
+
+
+ /**
+ * Confirms the 'invalid argument index number behaviour' for the given command
+ * targeting a single task in the shown list, using visible index.
+ * @param commandWord to test assuming it targets a single task in the last shown list based on visible index.
+ */
+ private void assertIncorrectIndexFormatBehaviorForCommand(String commandWord, String expectedMessage) throws Exception {
+ assertCommandBehavior(commandWord , expectedMessage); //index missing
+ assertCommandBehavior(commandWord + " +1", expectedMessage); //index should be unsigned
+ assertCommandBehavior(commandWord + " -1", expectedMessage); //index should be unsigned
+ assertCommandBehavior(commandWord + " 0", expectedMessage); //index cannot be 0
+ assertCommandBehavior(commandWord + " not_a_number", expectedMessage);
+ }
+
+ /**
+ * Confirms the 'invalid argument index number behaviour' for the given command
+ * targeting a single task in the shown list, using visible index.
+ * @param commandWord to test assuming it targets a single task in the last shown list based on visible index.
+ */
+ private void assertIndexNotFoundBehaviorForCommand(String commandWord) throws Exception {
+ String expectedMessage = MESSAGE_INVALID_TASK_DISPLAYED_INDEX;
+ TestDataHelper helper = new TestDataHelper();
+ List taskList = helper.generateTaskList(2);
+
+ // set AB state to 2 tasks
+ model.clearTaskList();
+ for (Task p : taskList) {
+ model.addTask(p);
+ }
+
+ assertCommandBehavior(commandWord + " 3", expectedMessage, model.getAddressBook(), taskList);
+ }
+
+ @Test
+ public void execute_selectInvalidArgsFormat_errorMessageShown() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, SelectCommand.MESSAGE_USAGE);
+ assertIncorrectIndexFormatBehaviorForCommand("select", expectedMessage);
+ }
+
+ @Test
+ public void execute_selectIndexNotFound_errorMessageShown() throws Exception {
+ assertIndexNotFoundBehaviorForCommand("select");
+ }
+
+ @Test
+ public void execute_select_jumpsToCorrectTask() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ List threeTasks = helper.generateTaskList(3);
+
+ AddressBook expectedAB = helper.generateAddressBook(threeTasks);
+ helper.addToModel(model, threeTasks);
+
+ assertCommandBehavior("select 2",
+ String.format(SelectCommand.MESSAGE_SELECT_TASK_SUCCESS, 2),
+ expectedAB,
+ expectedAB.getTaskList());
+ assertEquals(1, targetedJumpIndex);
+ assertEquals(model.getFilteredTaskList().get(1), threeTasks.get(1));
+ }
+
+
+ @Test
+ public void execute_deleteInvalidArgsFormat_errorMessageShown() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE);
+ assertIncorrectIndexFormatBehaviorForCommand("delete", expectedMessage);
+ }
+
+ @Test
+ public void execute_deleteIndexNotFound_errorMessageShown() throws Exception {
+ assertIndexNotFoundBehaviorForCommand("delete");
+ }
+
+ @Test
+ public void execute_delete_removesCorrectTask() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ List threeTasks = helper.generateTaskList(3);
+
+ AddressBook expectedAB = helper.generateAddressBook(threeTasks);
+ expectedAB.removeTask(threeTasks.get(1));
+ helper.addToModel(model, threeTasks);
+
+ assertCommandBehavior("delete 2",
+ String.format(DeleteCommand.MESSAGE_DELETE_TASK_SUCCESS, threeTasks.get(1)),
+ expectedAB,
+ expectedAB.getTaskList());
+ }
+
+
+ @Test
+ public void execute_find_invalidArgsFormat() throws Exception {
+ String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, FindCommand.MESSAGE_USAGE);
+ assertCommandBehavior("find ", expectedMessage);
+ }
+
+ @Test
+ public void execute_find_onlyMatchesFullWordsInNames() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task pTarget1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task pTarget2 = helper.generateTaskWithName("bla KEY bla bceofeia");
+ Task p1 = helper.generateTaskWithName("KE Y");
+ Task p2 = helper.generateTaskWithName("KEYKEYKEY sduauo");
+
+ List fourTasks = helper.generateTaskList(p1, pTarget1, p2, pTarget2);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = helper.generateTaskList(pTarget1, pTarget2);
+ helper.addToModel(model, fourTasks);
+
+ assertCommandBehavior("find KEY",
+ Command.getMessageForTaskListShownSummary(expectedList.size()),
+ expectedAB,
+ expectedList);
+ }
+
+ @Test
+ public void execute_find_isNotCaseSensitive() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task p1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task p2 = helper.generateTaskWithName("bla KEY bla bceofeia");
+ Task p3 = helper.generateTaskWithName("key key");
+ Task p4 = helper.generateTaskWithName("KEy sduauo");
+
+ List fourTasks = helper.generateTaskList(p3, p1, p4, p2);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = fourTasks;
+ helper.addToModel(model, fourTasks);
+
+ assertCommandBehavior("find KEY",
+ Command.getMessageForTaskListShownSummary(expectedList.size()),
+ expectedAB,
+ expectedList);
+ }
+
+ @Test
+ public void execute_find_matchesIfAnyKeywordPresent() throws Exception {
+ TestDataHelper helper = new TestDataHelper();
+ Task pTarget1 = helper.generateTaskWithName("bla bla KEY bla");
+ Task pTarget2 = helper.generateTaskWithName("bla rAnDoM bla bceofeia");
+ Task pTarget3 = helper.generateTaskWithName("key key");
+ Task p1 = helper.generateTaskWithName("sduauo");
+
+ List fourTasks = helper.generateTaskList(pTarget1, p1, pTarget2, pTarget3);
+ AddressBook expectedAB = helper.generateAddressBook(fourTasks);
+ List expectedList = helper.generateTaskList(pTarget1, pTarget2, pTarget3);
+ helper.addToModel(model, fourTasks);
+
+ String keywords = "key rAnDoM";
+ TestFindHelper findhelper = new TestFindHelper();
+
+ assertCommandBehavior("find " + keywords,
+ String.format(findhelper.generateCorrectResultIfExactPhraseNotFound(keywords, expectedList.size())),
+ expectedAB,
+ expectedList);
+ }
+
+ class TestFindHelper{
+
+ String generateCorrectResultIfExactPhraseNotFound(String keywords, int expectedListSize) {
+ String task_tasks = (expectedListSize == 1) ? "task" : "tasks";
+ String MESSAGE_IF_EXACT_PHRASE_NOT_FOUND = "The exact phrase '" + keywords + "' was not found. Listing " + expectedListSize + " " + task_tasks + " containing the keywords entered instead.";
+ return MESSAGE_IF_EXACT_PHRASE_NOT_FOUND;
+ }
+ }
+
+
+ /**
+ * A utility class to generate test data.
+ */
+ class TestDataHelper{
+
+ Task adam() throws Exception {
+ Name name = new Name("Pick up laundry");
+ DueDate privateDueDate = new DueDate("noon");
+ Address address = new Address("111, alpha street");
+ Priority privatePriority = new Priority("1");
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, privateDueDate, address, privatePriority, tags);
+ }
+ Task adamChanged() throws Exception {
+ NaturalLanguageProcessor nlpTest = new DateNaturalLanguageProcessor();
+ String formattedDate = nlpTest.formatString("noon");
+ Name name = new Name("Pick up laundry");
+ DueDate privateDueDate = new DueDate(formattedDate);
+ Address address = new Address("111, alpha street");
+ Priority privatePriority = new Priority("1");
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, privateDueDate, address, privatePriority, tags);
+ }
+
+
+ Task optionalAddressDateChanged() throws Exception {
+ NaturalLanguageProcessor nlpTest = new DateNaturalLanguageProcessor();
+ String formattedDate = nlpTest.formatString("noon");
+ Name name = new Name("clean room");
+ DueDate privateDueDate = new DueDate(formattedDate);
+ Address address = new Address("none");
+ Priority privatePriority = new Priority("3");
+ Tag tag1 = new Tag("tag1");
+ UniqueTagList tags = new UniqueTagList(tag1);
+ return new Task(name, privateDueDate, address, privatePriority, tags);
+ }
+
+ /**
+ * Generates a valid task using the given seed.
+ * Running this function with the same parameter values guarantees the returned task will have the same state.
+ * Each unique seed will generate a unique Task object.
+ *
+ * @param seed used to generate the task data field values
+ */
+ Task generateTask(int seed) throws Exception {
+ return new Task(
+ new Name("Task " + seed),
+ new DueDate("" + Math.abs(seed)),
+ new Address(seed + ", -address"),
+ new Priority("1 " + seed),
+ new UniqueTagList(new Tag("tag" + Math.abs(seed)), new Tag("tag" + Math.abs(seed + 1)))
+ );
+ }
+
+ /** Generates the correct add command based on the task given */
+ String generateAddCommand(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("add ");
+
+ cmd.append(p.getName().toString());
+ cmd.append(" d/").append(p.getDueDate());
+ cmd.append(" a/").append(p.getAddress());
+ cmd.append(" p/").append(p.getPriority());
+
+ UniqueTagList tags = p.getTags();
+ for(Tag t: tags){
+ cmd.append(" t/").append(t.tagName);
+ }
+
+ return cmd.toString();
+ }
+
+ /** Generates the correct add command based on the task given */
+ String generateEditCommand(Task p) {
+ StringBuffer cmd = new StringBuffer();
+
+ cmd.append("edit ");
+ cmd.append(" d/").append(p.getDueDate());
+
+ return cmd.toString();
+ }
+
+ /**
+ * Generates an AddressBook with auto-generated tasks.
+ */
+ AddressBook generateAddressBook(int numGenerated) throws Exception{
+ AddressBook addressBook = new AddressBook();
+ addToAddressBook(addressBook, numGenerated);
+ return addressBook;
+ }
+
+ /**
+ * Generates an AddressBook based on the list of Tasks given.
+ */
+ AddressBook generateAddressBook(List tasks) throws Exception{
+ AddressBook addressBook = new AddressBook();
+ addToAddressBook(addressBook, tasks);
+ return addressBook;
+ }
+
+ /**
+ * Adds auto-generated Task objects to the given AddressBook
+ * @param addressBook The AddressBook to which the Tasks will be added
+ */
+ void addToAddressBook(AddressBook addressBook, int numGenerated) throws Exception{
+ addToAddressBook(addressBook, generateTaskList(numGenerated));
+ }
+
+ /**
+ * Adds the given list of Tasks to the given AddressBook
+ */
+ void addToAddressBook(AddressBook addressBook, List tasksToAdd) throws Exception{
+ for(Task p: tasksToAdd){
+ addressBook.addTask(p);
+ }
+ }
+
+ /**
+ * Adds auto-generated Task objects to the given model
+ * @param model The model to which the Tasks will be added
+ */
+ void addToModel(Model model, int numGenerated) throws Exception{
+ addToModel(model, generateTaskList(numGenerated));
+ }
+
+ /**
+ * Adds the given list of Tasks to the given model
+ */
+ void addToModel(Model model, List tasksToAdd) throws Exception{
+ for(Task p: tasksToAdd){
+ model.addTask(p);
+ }
+ }
+
+ /**
+ * Generates a list of Tasks based on the flags.
+ */
+ List generateTaskList(int numGenerated) throws Exception{
+ List tasks = new ArrayList<>();
+ for(int i = 1; i <= numGenerated; i++){
+ tasks.add(generateTask(i));
+ }
+ return tasks;
+ }
+
+ List generateTaskList(Task... tasks) {
+ return Arrays.asList(tasks);
+ }
+
+ /**
+ * Generates a Task object with given name. Other fields will have some dummy values.
+ */
+ Task generateTaskWithName(String name) throws Exception {
+ return new Task(
+ new Name(name),
+ new DueDate("1"),
+ new Address("House of 1"),
+ new Priority("1"),
+ new UniqueTagList(new Tag("tag"))
+ );
+ }
+ }
+}
+```
+###### /src/test/java/seedu/gtd/testutil/TestUtil.java
+``` java
+
+ public static String LS = System.lineSeparator();
+
+ public static void assertThrows(Class expected, Runnable executable) {
+ try {
+ executable.run();
+ }
+ catch (Throwable actualException) {
+ if (!actualException.getClass().isAssignableFrom(expected)) {
+ String message = String.format("Expected thrown: %s, actual: %s", expected.getName(),
+ actualException.getClass().getName());
+ throw new AssertionFailedError(message);
+ } else return;
+ }
+ throw new AssertionFailedError(
+ String.format("Expected %s to be thrown, but nothing was thrown.", expected.getName()));
+ }
+
+ /**
+ * Folder used for temp files created during testing. Ignored by Git.
+ */
+ public static String SANDBOX_FOLDER = FileUtil.getPath("./src/test/data/sandbox/");
+
+ public static final Task[] sampleTaskData = getSampleTaskData();
+
+ private static Task[] getSampleTaskData() {
+ try {
+ return new Task[]{
+ new Task(new Name("Ali Muster"), new DueDate("9482424"), new Address("4th street"), new Priority("4"), new UniqueTagList()),
+ new Task(new Name("Boris Mueller"), new DueDate("87249245"), new Address("81th street"), new Priority("3"), new UniqueTagList()),
+ new Task(new Name("Carl Kurz"), new DueDate("95352563"), new Address("wall street"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Daniel Meier"), new DueDate("87652533"), new Address("10th street"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Elle Meyer"), new DueDate("9482224"), new Address("michegan ave"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Fiona Kunz"), new DueDate("9482427"), new Address("little tokyo"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("George Best"), new DueDate("9482442"), new Address("4th street"), new Priority("4"), new UniqueTagList()),
+ new Task(new Name("Hoon Meier"), new DueDate("8482424"), new Address("little india"), new Priority("1"), new UniqueTagList()),
+ new Task(new Name("Ida Mueller"), new DueDate("8482131"), new Address("chicago ave"), new Priority("1"), new UniqueTagList())
+ };
+ } catch (IllegalValueException e) {
+ assert false;
+ //not possible
+ return null;
+ }
+ }
+
+ public static final Tag[] sampleTagData = getSampleTagData();
+
+ private static Tag[] getSampleTagData() {
+ try {
+ return new Tag[]{
+ new Tag("relatives"),
+ new Tag("friends")
+ };
+ } catch (IllegalValueException e) {
+ assert false;
+ return null;
+ //not possible
+ }
+ }
+
+ public static List generateSampleTaskData() {
+ return Arrays.asList(sampleTaskData);
+ }
+
+ /**
+ * Appends the file name to the sandbox folder path.
+ * Creates the sandbox folder if it doesn't exist.
+ * @param fileName
+ * @return
+ */
+ public static String getFilePathInSandboxFolder(String fileName) {
+ try {
+ FileUtil.createDirs(new File(SANDBOX_FOLDER));
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ return SANDBOX_FOLDER + fileName;
+ }
+
+ public static void createDataFileWithSampleData(String filePath) {
+ createDataFileWithData(generateSampleStorageAddressBook(), filePath);
+ }
+
+ public static void createDataFileWithData(T data, String filePath) {
+ try {
+ File saveFileForTesting = new File(filePath);
+ FileUtil.createIfMissing(saveFileForTesting);
+ XmlUtil.saveDataToFile(saveFileForTesting, data);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void main(String... s) {
+ createDataFileWithSampleData(TestApp.SAVE_LOCATION_FOR_TESTING);
+ }
+
+ public static AddressBook generateEmptyAddressBook() {
+ return new AddressBook(new UniqueTaskList(), new UniqueTagList());
+ }
+
+ public static XmlSerializableAddressBook generateSampleStorageAddressBook() {
+ return new XmlSerializableAddressBook(generateEmptyAddressBook());
+ }
+
+ /**
+ * Tweaks the {@code keyCodeCombination} to resolve the {@code KeyCode.SHORTCUT} to their
+ * respective platform-specific keycodes
+ */
+ public static KeyCode[] scrub(KeyCodeCombination keyCodeCombination) {
+ List keys = new ArrayList<>();
+ if (keyCodeCombination.getAlt() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.ALT);
+ }
+ if (keyCodeCombination.getShift() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.SHIFT);
+ }
+ if (keyCodeCombination.getMeta() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.META);
+ }
+ if (keyCodeCombination.getControl() == KeyCombination.ModifierValue.DOWN) {
+ keys.add(KeyCode.CONTROL);
+ }
+ keys.add(keyCodeCombination.getCode());
+ return keys.toArray(new KeyCode[]{});
+ }
+
+ public static boolean isHeadlessEnvironment() {
+ String headlessProperty = System.getProperty("testfx.headless");
+ return headlessProperty != null && headlessProperty.equals("true");
+ }
+
+ public static void captureScreenShot(String fileName) {
+ File file = GuiTest.captureScreenshot();
+ try {
+ Files.copy(file, new File(fileName + ".png"));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static String descOnFail(Object... comparedObjects) {
+ return "Comparison failed \n"
+ + Arrays.asList(comparedObjects).stream()
+ .map(Object::toString)
+ .collect(Collectors.joining("\n"));
+ }
+
+ public static void setFinalStatic(Field field, Object newValue) throws NoSuchFieldException, IllegalAccessException{
+ field.setAccessible(true);
+ // remove final modifier from field
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ // ~Modifier.FINAL is used to remove the final modifier from field so that its value is no longer
+ // final and can be changed
+ modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+ field.set(null, newValue);
+ }
+
+ public static void initRuntime() throws TimeoutException {
+ FxToolkit.registerPrimaryStage();
+ FxToolkit.hideStage();
+ }
+
+ public static void tearDownRuntime() throws Exception {
+ FxToolkit.cleanupStages();
+ }
+
+ /**
+ * Gets private method of a class
+ * Invoke the method using method.invoke(objectInstance, params...)
+ *
+ * Caveat: only find method declared in the current Class, not inherited from supertypes
+ */
+ public static Method getPrivateMethod(Class objectClass, String methodName) throws NoSuchMethodException {
+ Method method = objectClass.getDeclaredMethod(methodName);
+ method.setAccessible(true);
+ return method;
+ }
+
+ public static void renameFile(File file, String newFileName) {
+ try {
+ Files.copy(file, new File(newFileName));
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ }
+ }
+
+ /**
+ * Gets mid point of a node relative to the screen.
+ * @param node
+ * @return
+ */
+ public static Point2D getScreenMidPoint(Node node) {
+ double x = getScreenPos(node).getMinX() + node.getLayoutBounds().getWidth() / 2;
+ double y = getScreenPos(node).getMinY() + node.getLayoutBounds().getHeight() / 2;
+ return new Point2D(x,y);
+ }
+
+ /**
+ * Gets mid point of a node relative to its scene.
+ * @param node
+ * @return
+ */
+ public static Point2D getSceneMidPoint(Node node) {
+ double x = getScenePos(node).getMinX() + node.getLayoutBounds().getWidth() / 2;
+ double y = getScenePos(node).getMinY() + node.getLayoutBounds().getHeight() / 2;
+ return new Point2D(x,y);
+ }
+
+ /**
+ * Gets the bound of the node relative to the parent scene.
+ * @param node
+ * @return
+ */
+ public static Bounds getScenePos(Node node) {
+ return node.localToScene(node.getBoundsInLocal());
+ }
+
+ public static Bounds getScreenPos(Node node) {
+ return node.localToScreen(node.getBoundsInLocal());
+ }
+
+ public static double getSceneMaxX(Scene scene) {
+ return scene.getX() + scene.getWidth();
+ }
+
+ public static double getSceneMaxY(Scene scene) {
+ return scene.getX() + scene.getHeight();
+ }
+
+ public static Object getLastElement(List list) {
+ return list.get(list.size() - 1);
+ }
+
+ /**
+ * Removes a subset from the list of tasks.
+ * @param tasks The list of tasks
+ * @param tasksToRemove The subset of tasks.
+ * @return The modified tasks after removal of the subset from tasks.
+ */
+ public static TestTask[] removeTasksFromList(final TestTask[] tasks, TestTask... tasksToRemove) {
+ List listOfTasks = asList(tasks);
+ listOfTasks.removeAll(asList(tasksToRemove));
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+
+ /**
+ * Returns a copy of the list with the task at specified index removed.
+ * @param list original list to copy from
+ * @param targetIndexInOneIndexedFormat e.g. if the first element to be removed, 1 should be given as index.
+ */
+ public static TestTask[] removeTaskFromList(final TestTask[] list, int targetIndexInOneIndexedFormat) {
+ return removeTasksFromList(list, list[targetIndexInOneIndexedFormat-1]);
+ }
+
+ /**
+ * Replaces tasks[i] with a task.
+ * @param tasks The array of tasks.
+ * @param task The replacement task
+ * @param index The index of the task to be replaced.
+ * @return
+ */
+ public static TestTask[] replaceTaskFromList(TestTask[] tasks, TestTask task, int index) {
+ tasks[index] = task;
+ return tasks;
+ }
+
+ /**
+ * Appends tasks to the array of tasks.
+ * @param tasks A array of tasks.
+ * @param tasksToAdd The tasks that are to be appended behind the original array.
+ * @return The modified array of tasks.
+ */
+ public static TestTask[] addTasksToList(final TestTask[] tasks, TestTask... tasksToAdd) {
+ List listOfTasks = asList(tasks);
+ listOfTasks.addAll(asList(tasksToAdd));
+ return listOfTasks.toArray(new TestTask[listOfTasks.size()]);
+ }
+
+```
+###### /src/test/java/seedu/gtd/testutil/TestUtil.java
+``` java
+
+ private static List asList(T[] objs) {
+ List list = new ArrayList<>();
+ for(T obj : objs) {
+ list.add(obj);
+ }
+ return list;
+ }
+
+ public static boolean compareCardAndTask(TaskCardHandle card, ReadOnlyTask task) {
+ return card.isSameTask(task);
+ }
+
+ public static Tag[] getTagList(String tags) {
+
+ if (tags.equals("")) {
+ return new Tag[]{};
+ }
+
+ final String[] split = tags.split(", ");
+
+ final List collect = Arrays.asList(split).stream().map(e -> {
+ try {
+ return new Tag(e.replaceFirst("Tag: ", ""));
+ } catch (IllegalValueException e1) {
+ //not possible
+ assert false;
+ return null;
+ }
+ }).collect(Collectors.toList());
+
+ return collect.toArray(new Tag[split.length]);
+ }
+
+}
+```
diff --git a/libs/natty-0.7.jar b/libs/natty-0.7.jar
new file mode 100644
index 000000000000..c4767a3d7357
Binary files /dev/null and b/libs/natty-0.7.jar differ
diff --git a/src/main/java/seedu/address/commons/core/Messages.java b/src/main/java/seedu/address/commons/core/Messages.java
deleted file mode 100644
index 1deb3a1e4695..000000000000
--- a/src/main/java/seedu/address/commons/core/Messages.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package seedu.address.commons.core;
-
-/**
- * Container for user visible messages.
- */
-public class Messages {
-
- public static final String MESSAGE_UNKNOWN_COMMAND = "Unknown command";
- public static final String MESSAGE_INVALID_COMMAND_FORMAT = "Invalid command format! \n%1$s";
- public static final String MESSAGE_INVALID_PERSON_DISPLAYED_INDEX = "The person index provided is invalid";
- public static final String MESSAGE_PERSONS_LISTED_OVERVIEW = "%1$d persons listed!";
-
-}
diff --git a/src/main/java/seedu/address/commons/events/ui/PersonPanelSelectionChangedEvent.java b/src/main/java/seedu/address/commons/events/ui/PersonPanelSelectionChangedEvent.java
deleted file mode 100644
index 95377b326fa6..000000000000
--- a/src/main/java/seedu/address/commons/events/ui/PersonPanelSelectionChangedEvent.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package seedu.address.commons.events.ui;
-
-import seedu.address.commons.events.BaseEvent;
-import seedu.address.model.person.ReadOnlyPerson;
-
-/**
- * Represents a selection change in the Person List Panel
- */
-public class PersonPanelSelectionChangedEvent extends BaseEvent {
-
-
- private final ReadOnlyPerson newSelection;
-
- public PersonPanelSelectionChangedEvent(ReadOnlyPerson newSelection){
- this.newSelection = newSelection;
- }
-
- @Override
- public String toString() {
- return this.getClass().getSimpleName();
- }
-
- public ReadOnlyPerson getNewSelection() {
- return newSelection;
- }
-}
diff --git a/src/main/java/seedu/address/logic/commands/AddCommand.java b/src/main/java/seedu/address/logic/commands/AddCommand.java
deleted file mode 100644
index 2860a9ab2a85..000000000000
--- a/src/main/java/seedu/address/logic/commands/AddCommand.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package seedu.address.logic.commands;
-
-import seedu.address.commons.exceptions.IllegalValueException;
-import seedu.address.model.person.*;
-import seedu.address.model.tag.Tag;
-import seedu.address.model.tag.UniqueTagList;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Adds a person to the address book.
- */
-public class AddCommand extends Command {
-
- public static final String COMMAND_WORD = "add";
-
- public static final String MESSAGE_USAGE = COMMAND_WORD + ": Adds a person to the address book. "
- + "Parameters: NAME p/PHONE e/EMAIL a/ADDRESS [t/TAG]...\n"
- + "Example: " + COMMAND_WORD
- + " John Doe p/98765432 e/johnd@gmail.com a/311, Clementi Ave 2, #02-25 t/friends t/owesMoney";
-
- public static final String MESSAGE_SUCCESS = "New person added: %1$s";
- public static final String MESSAGE_DUPLICATE_PERSON = "This person already exists in the address book";
-
- private final Person toAdd;
-
- /**
- * Convenience constructor using raw values.
- *
- * @throws IllegalValueException if any of the raw values are invalid
- */
- public AddCommand(String name, String phone, String email, String address, Set tags)
- throws IllegalValueException {
- final Set tagSet = new HashSet<>();
- for (String tagName : tags) {
- tagSet.add(new Tag(tagName));
- }
- this.toAdd = new Person(
- new Name(name),
- new Phone(phone),
- new Email(email),
- new Address(address),
- new UniqueTagList(tagSet)
- );
- }
-
- @Override
- public CommandResult execute() {
- assert model != null;
- try {
- model.addPerson(toAdd);
- return new CommandResult(String.format(MESSAGE_SUCCESS, toAdd));
- } catch (UniquePersonList.DuplicatePersonException e) {
- return new CommandResult(MESSAGE_DUPLICATE_PERSON);
- }
-
- }
-
-}
diff --git a/src/main/java/seedu/address/logic/commands/DeleteCommand.java b/src/main/java/seedu/address/logic/commands/DeleteCommand.java
deleted file mode 100644
index 1bfebe8912a8..000000000000
--- a/src/main/java/seedu/address/logic/commands/DeleteCommand.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package seedu.address.logic.commands;
-
-import seedu.address.commons.core.Messages;
-import seedu.address.commons.core.UnmodifiableObservableList;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.model.person.UniquePersonList.PersonNotFoundException;
-
-/**
- * Deletes a person identified using it's last displayed index from the address book.
- */
-public class DeleteCommand extends Command {
-
- public static final String COMMAND_WORD = "delete";
-
- public static final String MESSAGE_USAGE = COMMAND_WORD
- + ": Deletes the person identified by the index number used in the last person listing.\n"
- + "Parameters: INDEX (must be a positive integer)\n"
- + "Example: " + COMMAND_WORD + " 1";
-
- public static final String MESSAGE_DELETE_PERSON_SUCCESS = "Deleted Person: %1$s";
-
- public final int targetIndex;
-
- public DeleteCommand(int targetIndex) {
- this.targetIndex = targetIndex;
- }
-
-
- @Override
- public CommandResult execute() {
-
- UnmodifiableObservableList lastShownList = model.getFilteredPersonList();
-
- if (lastShownList.size() < targetIndex) {
- indicateAttemptToExecuteIncorrectCommand();
- return new CommandResult(Messages.MESSAGE_INVALID_PERSON_DISPLAYED_INDEX);
- }
-
- ReadOnlyPerson personToDelete = lastShownList.get(targetIndex - 1);
-
- try {
- model.deletePerson(personToDelete);
- } catch (PersonNotFoundException pnfe) {
- assert false : "The target person cannot be missing";
- }
-
- return new CommandResult(String.format(MESSAGE_DELETE_PERSON_SUCCESS, personToDelete));
- }
-
-}
diff --git a/src/main/java/seedu/address/logic/commands/FindCommand.java b/src/main/java/seedu/address/logic/commands/FindCommand.java
deleted file mode 100644
index 1d61bf6cc857..000000000000
--- a/src/main/java/seedu/address/logic/commands/FindCommand.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package seedu.address.logic.commands;
-
-import java.util.Set;
-
-/**
- * Finds and lists all persons in address book whose name contains any of the argument keywords.
- * Keyword matching is case sensitive.
- */
-public class FindCommand extends Command {
-
- public static final String COMMAND_WORD = "find";
-
- public static final String MESSAGE_USAGE = COMMAND_WORD + ": Finds all persons whose names contain any of "
- + "the specified keywords (case-sensitive) and displays them as a list with index numbers.\n"
- + "Parameters: KEYWORD [MORE_KEYWORDS]...\n"
- + "Example: " + COMMAND_WORD + " alice bob charlie";
-
- private final Set keywords;
-
- public FindCommand(Set keywords) {
- this.keywords = keywords;
- }
-
- @Override
- public CommandResult execute() {
- model.updateFilteredPersonList(keywords);
- return new CommandResult(getMessageForPersonListShownSummary(model.getFilteredPersonList().size()));
- }
-
-}
diff --git a/src/main/java/seedu/address/logic/commands/HelpCommand.java b/src/main/java/seedu/address/logic/commands/HelpCommand.java
deleted file mode 100644
index 65af96940242..000000000000
--- a/src/main/java/seedu/address/logic/commands/HelpCommand.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package seedu.address.logic.commands;
-
-
-import seedu.address.commons.core.EventsCenter;
-import seedu.address.commons.events.ui.ShowHelpRequestEvent;
-
-/**
- * Format full help instructions for every command for display.
- */
-public class HelpCommand extends Command {
-
- public static final String COMMAND_WORD = "help";
-
- public static final String MESSAGE_USAGE = COMMAND_WORD + ": Shows program usage instructions.\n"
- + "Example: " + COMMAND_WORD;
-
- public static final String SHOWING_HELP_MESSAGE = "Opened help window.";
-
- public HelpCommand() {}
-
- @Override
- public CommandResult execute() {
- EventsCenter.getInstance().post(new ShowHelpRequestEvent());
- return new CommandResult(SHOWING_HELP_MESSAGE);
- }
-}
diff --git a/src/main/java/seedu/address/logic/commands/ListCommand.java b/src/main/java/seedu/address/logic/commands/ListCommand.java
deleted file mode 100644
index 9bdd457a1b01..000000000000
--- a/src/main/java/seedu/address/logic/commands/ListCommand.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package seedu.address.logic.commands;
-
-
-/**
- * Lists all persons in the address book to the user.
- */
-public class ListCommand extends Command {
-
- public static final String COMMAND_WORD = "list";
-
- public static final String MESSAGE_SUCCESS = "Listed all persons";
-
- public ListCommand() {}
-
- @Override
- public CommandResult execute() {
- model.updateFilteredListToShowAll();
- return new CommandResult(MESSAGE_SUCCESS);
- }
-}
diff --git a/src/main/java/seedu/address/logic/commands/SelectCommand.java b/src/main/java/seedu/address/logic/commands/SelectCommand.java
deleted file mode 100644
index 9ca0551f1951..000000000000
--- a/src/main/java/seedu/address/logic/commands/SelectCommand.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package seedu.address.logic.commands;
-
-import seedu.address.commons.core.EventsCenter;
-import seedu.address.commons.core.Messages;
-import seedu.address.commons.events.ui.JumpToListRequestEvent;
-import seedu.address.commons.core.UnmodifiableObservableList;
-import seedu.address.model.person.ReadOnlyPerson;
-
-/**
- * Selects a person identified using it's last displayed index from the address book.
- */
-public class SelectCommand extends Command {
-
- public final int targetIndex;
-
- public static final String COMMAND_WORD = "select";
-
- public static final String MESSAGE_USAGE = COMMAND_WORD
- + ": Selects the person identified by the index number used in the last person listing.\n"
- + "Parameters: INDEX (must be a positive integer)\n"
- + "Example: " + COMMAND_WORD + " 1";
-
- public static final String MESSAGE_SELECT_PERSON_SUCCESS = "Selected Person: %1$s";
-
- public SelectCommand(int targetIndex) {
- this.targetIndex = targetIndex;
- }
-
- @Override
- public CommandResult execute() {
-
- UnmodifiableObservableList lastShownList = model.getFilteredPersonList();
-
- if (lastShownList.size() < targetIndex) {
- indicateAttemptToExecuteIncorrectCommand();
- return new CommandResult(Messages.MESSAGE_INVALID_PERSON_DISPLAYED_INDEX);
- }
-
- EventsCenter.getInstance().post(new JumpToListRequestEvent(targetIndex - 1));
- return new CommandResult(String.format(MESSAGE_SELECT_PERSON_SUCCESS, targetIndex));
-
- }
-
-}
diff --git a/src/main/java/seedu/address/logic/parser/Parser.java b/src/main/java/seedu/address/logic/parser/Parser.java
deleted file mode 100644
index 959b2cd0383c..000000000000
--- a/src/main/java/seedu/address/logic/parser/Parser.java
+++ /dev/null
@@ -1,192 +0,0 @@
-package seedu.address.logic.parser;
-
-import seedu.address.logic.commands.*;
-import seedu.address.commons.util.StringUtil;
-import seedu.address.commons.exceptions.IllegalValueException;
-
-import java.util.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
-import static seedu.address.commons.core.Messages.MESSAGE_UNKNOWN_COMMAND;
-
-/**
- * Parses user input.
- */
-public class Parser {
-
- /**
- * Used for initial separation of command word and args.
- */
- private static final Pattern BASIC_COMMAND_FORMAT = Pattern.compile("(?\\S+)(?.*)");
-
- private static final Pattern PERSON_INDEX_ARGS_FORMAT = Pattern.compile("(?.+)");
-
- private static final Pattern KEYWORDS_ARGS_FORMAT =
- Pattern.compile("(?\\S+(?:\\s+\\S+)*)"); // one or more keywords separated by whitespace
-
- private static final Pattern PERSON_DATA_ARGS_FORMAT = // '/' forward slashes are reserved for delimiter prefixes
- Pattern.compile("(?[^/]+)"
- + " (?p?)p/(?[^/]+)"
- + " (?p?)e/(?[^/]+)"
- + " (?p?)a/(?[^/]+)"
- + "(?(?: t/[^/]+)*)"); // variable number of tags
-
- public Parser() {}
-
- /**
- * Parses user input into command for execution.
- *
- * @param userInput full user input string
- * @return the command based on the user input
- */
- public Command parseCommand(String userInput) {
- final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(userInput.trim());
- if (!matcher.matches()) {
- return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
- }
-
- final String commandWord = matcher.group("commandWord");
- final String arguments = matcher.group("arguments");
- switch (commandWord) {
-
- case AddCommand.COMMAND_WORD:
- return prepareAdd(arguments);
-
- case SelectCommand.COMMAND_WORD:
- return prepareSelect(arguments);
-
- case DeleteCommand.COMMAND_WORD:
- return prepareDelete(arguments);
-
- case ClearCommand.COMMAND_WORD:
- return new ClearCommand();
-
- case FindCommand.COMMAND_WORD:
- return prepareFind(arguments);
-
- case ListCommand.COMMAND_WORD:
- return new ListCommand();
-
- case ExitCommand.COMMAND_WORD:
- return new ExitCommand();
-
- case HelpCommand.COMMAND_WORD:
- return new HelpCommand();
-
- default:
- return new IncorrectCommand(MESSAGE_UNKNOWN_COMMAND);
- }
- }
-
- /**
- * Parses arguments in the context of the add person command.
- *
- * @param args full command args string
- * @return the prepared command
- */
- private Command prepareAdd(String args){
- final Matcher matcher = PERSON_DATA_ARGS_FORMAT.matcher(args.trim());
- // Validate arg string format
- if (!matcher.matches()) {
- return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE));
- }
- try {
- return new AddCommand(
- matcher.group("name"),
- matcher.group("phone"),
- matcher.group("email"),
- matcher.group("address"),
- getTagsFromArgs(matcher.group("tagArguments"))
- );
- } catch (IllegalValueException ive) {
- return new IncorrectCommand(ive.getMessage());
- }
- }
-
- /**
- * Extracts the new person's tags from the add command's tag arguments string.
- * Merges duplicate tag strings.
- */
- private static Set getTagsFromArgs(String tagArguments) throws IllegalValueException {
- // no tags
- if (tagArguments.isEmpty()) {
- return Collections.emptySet();
- }
- // replace first delimiter prefix, then split
- final Collection tagStrings = Arrays.asList(tagArguments.replaceFirst(" t/", "").split(" t/"));
- return new HashSet<>(tagStrings);
- }
-
- /**
- * Parses arguments in the context of the delete person command.
- *
- * @param args full command args string
- * @return the prepared command
- */
- private Command prepareDelete(String args) {
-
- Optional index = parseIndex(args);
- if(!index.isPresent()){
- return new IncorrectCommand(
- String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE));
- }
-
- return new DeleteCommand(index.get());
- }
-
- /**
- * Parses arguments in the context of the select person command.
- *
- * @param args full command args string
- * @return the prepared command
- */
- private Command prepareSelect(String args) {
- Optional index = parseIndex(args);
- if(!index.isPresent()){
- return new IncorrectCommand(
- String.format(MESSAGE_INVALID_COMMAND_FORMAT, SelectCommand.MESSAGE_USAGE));
- }
-
- return new SelectCommand(index.get());
- }
-
- /**
- * Returns the specified index in the {@code command} IF a positive unsigned integer is given as the index.
- * Returns an {@code Optional.empty()} otherwise.
- */
- private Optional parseIndex(String command) {
- final Matcher matcher = PERSON_INDEX_ARGS_FORMAT.matcher(command.trim());
- if (!matcher.matches()) {
- return Optional.empty();
- }
-
- String index = matcher.group("targetIndex");
- if(!StringUtil.isUnsignedInteger(index)){
- return Optional.empty();
- }
- return Optional.of(Integer.parseInt(index));
-
- }
-
- /**
- * Parses arguments in the context of the find person command.
- *
- * @param args full command args string
- * @return the prepared command
- */
- private Command prepareFind(String args) {
- final Matcher matcher = KEYWORDS_ARGS_FORMAT.matcher(args.trim());
- if (!matcher.matches()) {
- return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
- FindCommand.MESSAGE_USAGE));
- }
-
- // keywords delimited by whitespace
- final String[] keywords = matcher.group("keywords").split("\\s+");
- final Set keywordSet = new HashSet<>(Arrays.asList(keywords));
- return new FindCommand(keywordSet);
- }
-
-}
\ No newline at end of file
diff --git a/src/main/java/seedu/address/model/AddressBook.java b/src/main/java/seedu/address/model/AddressBook.java
deleted file mode 100644
index 298cc1b82ce8..000000000000
--- a/src/main/java/seedu/address/model/AddressBook.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package seedu.address.model;
-
-import javafx.collections.ObservableList;
-import seedu.address.model.person.Person;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.model.person.UniquePersonList;
-import seedu.address.model.tag.Tag;
-import seedu.address.model.tag.UniqueTagList;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-/**
- * Wraps all data at the address-book level
- * Duplicates are not allowed (by .equals comparison)
- */
-public class AddressBook implements ReadOnlyAddressBook {
-
- private final UniquePersonList persons;
- private final UniqueTagList tags;
-
- {
- persons = new UniquePersonList();
- tags = new UniqueTagList();
- }
-
- public AddressBook() {}
-
- /**
- * Persons and Tags are copied into this addressbook
- */
- public AddressBook(ReadOnlyAddressBook toBeCopied) {
- this(toBeCopied.getUniquePersonList(), toBeCopied.getUniqueTagList());
- }
-
- /**
- * Persons and Tags are copied into this addressbook
- */
- public AddressBook(UniquePersonList persons, UniqueTagList tags) {
- resetData(persons.getInternalList(), tags.getInternalList());
- }
-
- public static ReadOnlyAddressBook getEmptyAddressBook() {
- return new AddressBook();
- }
-
-//// list overwrite operations
-
- public ObservableList getPersons() {
- return persons.getInternalList();
- }
-
- public void setPersons(List persons) {
- this.persons.getInternalList().setAll(persons);
- }
-
- public void setTags(Collection tags) {
- this.tags.getInternalList().setAll(tags);
- }
-
- public void resetData(Collection newPersons, Collection newTags) {
- setPersons(newPersons.stream().map(Person::new).collect(Collectors.toList()));
- setTags(newTags);
- }
-
- public void resetData(ReadOnlyAddressBook newData) {
- resetData(newData.getPersonList(), newData.getTagList());
- }
-
-//// person-level operations
-
- /**
- * Adds a person to the address book.
- * Also checks the new person's tags and updates {@link #tags} with any new tags found,
- * and updates the Tag objects in the person to point to those in {@link #tags}.
- *
- * @throws UniquePersonList.DuplicatePersonException if an equivalent person already exists.
- */
- public void addPerson(Person p) throws UniquePersonList.DuplicatePersonException {
- syncTagsWithMasterList(p);
- persons.add(p);
- }
-
- /**
- * Ensures that every tag in this person:
- * - exists in the master list {@link #tags}
- * - points to a Tag object in the master list
- */
- private void syncTagsWithMasterList(Person person) {
- final UniqueTagList personTags = person.getTags();
- tags.mergeFrom(personTags);
-
- // Create map with values = tag object references in the master list
- final Map masterTagObjects = new HashMap<>();
- for (Tag tag : tags) {
- masterTagObjects.put(tag, tag);
- }
-
- // Rebuild the list of person tags using references from the master list
- final Set commonTagReferences = new HashSet<>();
- for (Tag tag : personTags) {
- commonTagReferences.add(masterTagObjects.get(tag));
- }
- person.setTags(new UniqueTagList(commonTagReferences));
- }
-
- public boolean removePerson(ReadOnlyPerson key) throws UniquePersonList.PersonNotFoundException {
- if (persons.remove(key)) {
- return true;
- } else {
- throw new UniquePersonList.PersonNotFoundException();
- }
- }
-
-//// tag-level operations
-
- public void addTag(Tag t) throws UniqueTagList.DuplicateTagException {
- tags.add(t);
- }
-
-//// util methods
-
- @Override
- public String toString() {
- return persons.getInternalList().size() + " persons, " + tags.getInternalList().size() + " tags";
- // TODO: refine later
- }
-
- @Override
- public List getPersonList() {
- return Collections.unmodifiableList(persons.getInternalList());
- }
-
- @Override
- public List getTagList() {
- return Collections.unmodifiableList(tags.getInternalList());
- }
-
- @Override
- public UniquePersonList getUniquePersonList() {
- return this.persons;
- }
-
- @Override
- public UniqueTagList getUniqueTagList() {
- return this.tags;
- }
-
-
- @Override
- public boolean equals(Object other) {
- return other == this // short circuit if same object
- || (other instanceof AddressBook // instanceof handles nulls
- && this.persons.equals(((AddressBook) other).persons)
- && this.tags.equals(((AddressBook) other).tags));
- }
-
- @Override
- public int hashCode() {
- // use this method for custom fields hashing instead of implementing your own
- return Objects.hash(persons, tags);
- }
-}
diff --git a/src/main/java/seedu/address/model/Model.java b/src/main/java/seedu/address/model/Model.java
deleted file mode 100644
index d14a27a93b5e..000000000000
--- a/src/main/java/seedu/address/model/Model.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package seedu.address.model;
-
-import seedu.address.commons.core.UnmodifiableObservableList;
-import seedu.address.model.person.Person;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.model.person.UniquePersonList;
-
-import java.util.Set;
-
-/**
- * The API of the Model component.
- */
-public interface Model {
- /** Clears existing backing model and replaces with the provided new data. */
- void resetData(ReadOnlyAddressBook newData);
-
- /** Returns the AddressBook */
- ReadOnlyAddressBook getAddressBook();
-
- /** Deletes the given person. */
- void deletePerson(ReadOnlyPerson target) throws UniquePersonList.PersonNotFoundException;
-
- /** Adds the given person */
- void addPerson(Person person) throws UniquePersonList.DuplicatePersonException;
-
- /** Returns the filtered person list as an {@code UnmodifiableObservableList} */
- UnmodifiableObservableList getFilteredPersonList();
-
- /** Updates the filter of the filtered person list to show all persons */
- void updateFilteredListToShowAll();
-
- /** Updates the filter of the filtered person list to filter by the given keywords*/
- void updateFilteredPersonList(Set keywords);
-
-}
diff --git a/src/main/java/seedu/address/model/ModelManager.java b/src/main/java/seedu/address/model/ModelManager.java
deleted file mode 100644
index 869226d02bf1..000000000000
--- a/src/main/java/seedu/address/model/ModelManager.java
+++ /dev/null
@@ -1,153 +0,0 @@
-package seedu.address.model;
-
-import javafx.collections.transformation.FilteredList;
-import seedu.address.commons.core.LogsCenter;
-import seedu.address.commons.core.UnmodifiableObservableList;
-import seedu.address.commons.util.StringUtil;
-import seedu.address.commons.events.model.AddressBookChangedEvent;
-import seedu.address.commons.core.ComponentManager;
-import seedu.address.model.person.Person;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.model.person.UniquePersonList;
-import seedu.address.model.person.UniquePersonList.PersonNotFoundException;
-
-import java.util.Set;
-import java.util.logging.Logger;
-
-/**
- * Represents the in-memory model of the address book data.
- * All changes to any model should be synchronized.
- */
-public class ModelManager extends ComponentManager implements Model {
- private static final Logger logger = LogsCenter.getLogger(ModelManager.class);
-
- private final AddressBook addressBook;
- private final FilteredList filteredPersons;
-
- /**
- * Initializes a ModelManager with the given AddressBook
- * AddressBook and its variables should not be null
- */
- public ModelManager(AddressBook src, UserPrefs userPrefs) {
- super();
- assert src != null;
- assert userPrefs != null;
-
- logger.fine("Initializing with address book: " + src + " and user prefs " + userPrefs);
-
- addressBook = new AddressBook(src);
- filteredPersons = new FilteredList<>(addressBook.getPersons());
- }
-
- public ModelManager() {
- this(new AddressBook(), new UserPrefs());
- }
-
- public ModelManager(ReadOnlyAddressBook initialData, UserPrefs userPrefs) {
- addressBook = new AddressBook(initialData);
- filteredPersons = new FilteredList<>(addressBook.getPersons());
- }
-
- @Override
- public void resetData(ReadOnlyAddressBook newData) {
- addressBook.resetData(newData);
- indicateAddressBookChanged();
- }
-
- @Override
- public ReadOnlyAddressBook getAddressBook() {
- return addressBook;
- }
-
- /** Raises an event to indicate the model has changed */
- private void indicateAddressBookChanged() {
- raise(new AddressBookChangedEvent(addressBook));
- }
-
- @Override
- public synchronized void deletePerson(ReadOnlyPerson target) throws PersonNotFoundException {
- addressBook.removePerson(target);
- indicateAddressBookChanged();
- }
-
- @Override
- public synchronized void addPerson(Person person) throws UniquePersonList.DuplicatePersonException {
- addressBook.addPerson(person);
- updateFilteredListToShowAll();
- indicateAddressBookChanged();
- }
-
- //=========== Filtered Person List Accessors ===============================================================
-
- @Override
- public UnmodifiableObservableList getFilteredPersonList() {
- return new UnmodifiableObservableList<>(filteredPersons);
- }
-
- @Override
- public void updateFilteredListToShowAll() {
- filteredPersons.setPredicate(null);
- }
-
- @Override
- public void updateFilteredPersonList(Set keywords){
- updateFilteredPersonList(new PredicateExpression(new NameQualifier(keywords)));
- }
-
- private void updateFilteredPersonList(Expression expression) {
- filteredPersons.setPredicate(expression::satisfies);
- }
-
- //========== Inner classes/interfaces used for filtering ==================================================
-
- interface Expression {
- boolean satisfies(ReadOnlyPerson person);
- String toString();
- }
-
- private class PredicateExpression implements Expression {
-
- private final Qualifier qualifier;
-
- PredicateExpression(Qualifier qualifier) {
- this.qualifier = qualifier;
- }
-
- @Override
- public boolean satisfies(ReadOnlyPerson person) {
- return qualifier.run(person);
- }
-
- @Override
- public String toString() {
- return qualifier.toString();
- }
- }
-
- interface Qualifier {
- boolean run(ReadOnlyPerson person);
- String toString();
- }
-
- private class NameQualifier implements Qualifier {
- private Set nameKeyWords;
-
- NameQualifier(Set nameKeyWords) {
- this.nameKeyWords = nameKeyWords;
- }
-
- @Override
- public boolean run(ReadOnlyPerson person) {
- return nameKeyWords.stream()
- .filter(keyword -> StringUtil.containsIgnoreCase(person.getName().fullName, keyword))
- .findAny()
- .isPresent();
- }
-
- @Override
- public String toString() {
- return "name=" + String.join(", ", nameKeyWords);
- }
- }
-
-}
diff --git a/src/main/java/seedu/address/model/ReadOnlyAddressBook.java b/src/main/java/seedu/address/model/ReadOnlyAddressBook.java
deleted file mode 100644
index bfca099b1e81..000000000000
--- a/src/main/java/seedu/address/model/ReadOnlyAddressBook.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package seedu.address.model;
-
-
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.model.person.UniquePersonList;
-import seedu.address.model.tag.Tag;
-import seedu.address.model.tag.UniqueTagList;
-
-import java.util.List;
-
-/**
- * Unmodifiable view of an address book
- */
-public interface ReadOnlyAddressBook {
-
- UniqueTagList getUniqueTagList();
-
- UniquePersonList getUniquePersonList();
-
- /**
- * Returns an unmodifiable view of persons list
- */
- List getPersonList();
-
- /**
- * Returns an unmodifiable view of tags list
- */
- List getTagList();
-
-}
diff --git a/src/main/java/seedu/address/model/person/Email.java b/src/main/java/seedu/address/model/person/Email.java
deleted file mode 100644
index 5da4d1078236..000000000000
--- a/src/main/java/seedu/address/model/person/Email.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package seedu.address.model.person;
-
-
-import seedu.address.commons.exceptions.IllegalValueException;
-
-/**
- * Represents a Person's phone number in the address book.
- * Guarantees: immutable; is valid as declared in {@link #isValidEmail(String)}
- */
-public class Email {
-
- public static final String MESSAGE_EMAIL_CONSTRAINTS =
- "Person emails should be 2 alphanumeric/period strings separated by '@'";
- public static final String EMAIL_VALIDATION_REGEX = "[\\w\\.]+@[\\w\\.]+";
-
- public final String value;
-
- /**
- * Validates given email.
- *
- * @throws IllegalValueException if given email address string is invalid.
- */
- public Email(String email) throws IllegalValueException {
- assert email != null;
- email = email.trim();
- if (!isValidEmail(email)) {
- throw new IllegalValueException(MESSAGE_EMAIL_CONSTRAINTS);
- }
- this.value = email;
- }
-
- /**
- * Returns if a given string is a valid person email.
- */
- public static boolean isValidEmail(String test) {
- return test.matches(EMAIL_VALIDATION_REGEX);
- }
-
- @Override
- public String toString() {
- return value;
- }
-
- @Override
- public boolean equals(Object other) {
- return other == this // short circuit if same object
- || (other instanceof Email // instanceof handles nulls
- && this.value.equals(((Email) other).value)); // state check
- }
-
- @Override
- public int hashCode() {
- return value.hashCode();
- }
-
-}
diff --git a/src/main/java/seedu/address/model/person/Person.java b/src/main/java/seedu/address/model/person/Person.java
deleted file mode 100644
index 03ffce7d2e79..000000000000
--- a/src/main/java/seedu/address/model/person/Person.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package seedu.address.model.person;
-
-import seedu.address.commons.util.CollectionUtil;
-import seedu.address.model.tag.UniqueTagList;
-
-import java.util.Objects;
-
-/**
- * Represents a Person in the address book.
- * Guarantees: details are present and not null, field values are validated.
- */
-public class Person implements ReadOnlyPerson {
-
- private Name name;
- private Phone phone;
- private Email email;
- private Address address;
-
- private UniqueTagList tags;
-
- /**
- * Every field must be present and not null.
- */
- public Person(Name name, Phone phone, Email email, Address address, UniqueTagList tags) {
- assert !CollectionUtil.isAnyNull(name, phone, email, address, tags);
- this.name = name;
- this.phone = phone;
- this.email = email;
- this.address = address;
- this.tags = new UniqueTagList(tags); // protect internal tags from changes in the arg list
- }
-
- /**
- * Copy constructor.
- */
- public Person(ReadOnlyPerson source) {
- this(source.getName(), source.getPhone(), source.getEmail(), source.getAddress(), source.getTags());
- }
-
- @Override
- public Name getName() {
- return name;
- }
-
- @Override
- public Phone getPhone() {
- return phone;
- }
-
- @Override
- public Email getEmail() {
- return email;
- }
-
- @Override
- public Address getAddress() {
- return address;
- }
-
- @Override
- public UniqueTagList getTags() {
- return new UniqueTagList(tags);
- }
-
- /**
- * Replaces this person's tags with the tags in the argument tag list.
- */
- public void setTags(UniqueTagList replacement) {
- tags.setTags(replacement);
- }
-
- @Override
- public boolean equals(Object other) {
- return other == this // short circuit if same object
- || (other instanceof ReadOnlyPerson // instanceof handles nulls
- && this.isSameStateAs((ReadOnlyPerson) other));
- }
-
- @Override
- public int hashCode() {
- // use this method for custom fields hashing instead of implementing your own
- return Objects.hash(name, phone, email, address, tags);
- }
-
- @Override
- public String toString() {
- return getAsText();
- }
-
-}
diff --git a/src/main/java/seedu/address/model/person/Phone.java b/src/main/java/seedu/address/model/person/Phone.java
deleted file mode 100644
index d27b2244b727..000000000000
--- a/src/main/java/seedu/address/model/person/Phone.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package seedu.address.model.person;
-
-import seedu.address.commons.exceptions.IllegalValueException;
-
-/**
- * Represents a Person's phone number in the address book.
- * Guarantees: immutable; is valid as declared in {@link #isValidPhone(String)}
- */
-public class Phone {
-
- public static final String MESSAGE_PHONE_CONSTRAINTS = "Person phone numbers should only contain numbers";
- public static final String PHONE_VALIDATION_REGEX = "\\d+";
-
- public final String value;
-
- /**
- * Validates given phone number.
- *
- * @throws IllegalValueException if given phone string is invalid.
- */
- public Phone(String phone) throws IllegalValueException {
- assert phone != null;
- phone = phone.trim();
- if (!isValidPhone(phone)) {
- throw new IllegalValueException(MESSAGE_PHONE_CONSTRAINTS);
- }
- this.value = phone;
- }
-
- /**
- * Returns true if a given string is a valid person phone number.
- */
- public static boolean isValidPhone(String test) {
- return test.matches(PHONE_VALIDATION_REGEX);
- }
-
- @Override
- public String toString() {
- return value;
- }
-
- @Override
- public boolean equals(Object other) {
- return other == this // short circuit if same object
- || (other instanceof Phone // instanceof handles nulls
- && this.value.equals(((Phone) other).value)); // state check
- }
-
- @Override
- public int hashCode() {
- return value.hashCode();
- }
-
-}
diff --git a/src/main/java/seedu/address/model/person/UniquePersonList.java b/src/main/java/seedu/address/model/person/UniquePersonList.java
deleted file mode 100644
index 263f1fcc7dd5..000000000000
--- a/src/main/java/seedu/address/model/person/UniquePersonList.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package seedu.address.model.person;
-
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import seedu.address.commons.util.CollectionUtil;
-import seedu.address.commons.exceptions.DuplicateDataException;
-
-import java.util.*;
-
-/**
- * A list of persons that enforces uniqueness between its elements and does not allow nulls.
- *
- * Supports a minimal set of list operations.
- *
- * @see Person#equals(Object)
- * @see CollectionUtil#elementsAreUnique(Collection)
- */
-public class UniquePersonList implements Iterable {
-
- /**
- * Signals that an operation would have violated the 'no duplicates' property of the list.
- */
- public static class DuplicatePersonException extends DuplicateDataException {
- protected DuplicatePersonException() {
- super("Operation would result in duplicate persons");
- }
- }
-
- /**
- * Signals that an operation targeting a specified person in the list would fail because
- * there is no such matching person in the list.
- */
- public static class PersonNotFoundException extends Exception {}
-
- private final ObservableList internalList = FXCollections.observableArrayList();
-
- /**
- * Constructs empty PersonList.
- */
- public UniquePersonList() {}
-
- /**
- * Returns true if the list contains an equivalent person as the given argument.
- */
- public boolean contains(ReadOnlyPerson toCheck) {
- assert toCheck != null;
- return internalList.contains(toCheck);
- }
-
- /**
- * Adds a person to the list.
- *
- * @throws DuplicatePersonException if the person to add is a duplicate of an existing person in the list.
- */
- public void add(Person toAdd) throws DuplicatePersonException {
- assert toAdd != null;
- if (contains(toAdd)) {
- throw new DuplicatePersonException();
- }
- internalList.add(toAdd);
- }
-
- /**
- * Removes the equivalent person from the list.
- *
- * @throws PersonNotFoundException if no such person could be found in the list.
- */
- public boolean remove(ReadOnlyPerson toRemove) throws PersonNotFoundException {
- assert toRemove != null;
- final boolean personFoundAndDeleted = internalList.remove(toRemove);
- if (!personFoundAndDeleted) {
- throw new PersonNotFoundException();
- }
- return personFoundAndDeleted;
- }
-
- public ObservableList getInternalList() {
- return internalList;
- }
-
- @Override
- public Iterator iterator() {
- return internalList.iterator();
- }
-
- @Override
- public boolean equals(Object other) {
- return other == this // short circuit if same object
- || (other instanceof UniquePersonList // instanceof handles nulls
- && this.internalList.equals(
- ((UniquePersonList) other).internalList));
- }
-
- @Override
- public int hashCode() {
- return internalList.hashCode();
- }
-}
diff --git a/src/main/java/seedu/address/storage/XmlAdaptedPerson.java b/src/main/java/seedu/address/storage/XmlAdaptedPerson.java
deleted file mode 100644
index f2167ec201b4..000000000000
--- a/src/main/java/seedu/address/storage/XmlAdaptedPerson.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package seedu.address.storage;
-
-import seedu.address.commons.exceptions.IllegalValueException;
-import seedu.address.model.person.*;
-import seedu.address.model.tag.Tag;
-import seedu.address.model.tag.UniqueTagList;
-
-import javax.xml.bind.annotation.XmlElement;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * JAXB-friendly version of the Person.
- */
-public class XmlAdaptedPerson {
-
- @XmlElement(required = true)
- private String name;
- @XmlElement(required = true)
- private String phone;
- @XmlElement(required = true)
- private String email;
- @XmlElement(required = true)
- private String address;
-
- @XmlElement
- private List tagged = new ArrayList<>();
-
- /**
- * No-arg constructor for JAXB use.
- */
- public XmlAdaptedPerson() {}
-
-
- /**
- * Converts a given Person into this class for JAXB use.
- *
- * @param source future changes to this will not affect the created XmlAdaptedPerson
- */
- public XmlAdaptedPerson(ReadOnlyPerson source) {
- name = source.getName().fullName;
- phone = source.getPhone().value;
- email = source.getEmail().value;
- address = source.getAddress().value;
- tagged = new ArrayList<>();
- for (Tag tag : source.getTags()) {
- tagged.add(new XmlAdaptedTag(tag));
- }
- }
-
- /**
- * Converts this jaxb-friendly adapted person object into the model's Person object.
- *
- * @throws IllegalValueException if there were any data constraints violated in the adapted person
- */
- public Person toModelType() throws IllegalValueException {
- final List personTags = new ArrayList<>();
- for (XmlAdaptedTag tag : tagged) {
- personTags.add(tag.toModelType());
- }
- final Name name = new Name(this.name);
- final Phone phone = new Phone(this.phone);
- final Email email = new Email(this.email);
- final Address address = new Address(this.address);
- final UniqueTagList tags = new UniqueTagList(personTags);
- return new Person(name, phone, email, address, tags);
- }
-}
diff --git a/src/main/java/seedu/address/ui/PersonCard.java b/src/main/java/seedu/address/ui/PersonCard.java
deleted file mode 100644
index 259e9ad0d333..000000000000
--- a/src/main/java/seedu/address/ui/PersonCard.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package seedu.address.ui;
-
-import javafx.fxml.FXML;
-import javafx.scene.Node;
-import javafx.scene.control.Label;
-import javafx.scene.layout.HBox;
-import seedu.address.model.person.ReadOnlyPerson;
-
-public class PersonCard extends UiPart{
-
- private static final String FXML = "PersonListCard.fxml";
-
- @FXML
- private HBox cardPane;
- @FXML
- private Label name;
- @FXML
- private Label id;
- @FXML
- private Label phone;
- @FXML
- private Label address;
- @FXML
- private Label email;
- @FXML
- private Label tags;
-
- private ReadOnlyPerson person;
- private int displayedIndex;
-
- public PersonCard(){
-
- }
-
- public static PersonCard load(ReadOnlyPerson person, int displayedIndex){
- PersonCard card = new PersonCard();
- card.person = person;
- card.displayedIndex = displayedIndex;
- return UiPartLoader.loadUiPart(card);
- }
-
- @FXML
- public void initialize() {
- name.setText(person.getName().fullName);
- id.setText(displayedIndex + ". ");
- phone.setText(person.getPhone().value);
- address.setText(person.getAddress().value);
- email.setText(person.getEmail().value);
- tags.setText(person.tagsString());
- }
-
- public HBox getLayout() {
- return cardPane;
- }
-
- @Override
- public void setNode(Node node) {
- cardPane = (HBox)node;
- }
-
- @Override
- public String getFxmlPath() {
- return FXML;
- }
-}
diff --git a/src/main/java/seedu/address/ui/PersonListPanel.java b/src/main/java/seedu/address/ui/PersonListPanel.java
deleted file mode 100644
index 27d9381c47b5..000000000000
--- a/src/main/java/seedu/address/ui/PersonListPanel.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package seedu.address.ui;
-
-import javafx.application.Platform;
-import javafx.collections.ObservableList;
-import javafx.fxml.FXML;
-import javafx.scene.Node;
-import javafx.scene.control.ListCell;
-import javafx.scene.control.ListView;
-import javafx.scene.control.SplitPane;
-import javafx.scene.layout.AnchorPane;
-import javafx.scene.layout.VBox;
-import javafx.stage.Stage;
-import seedu.address.commons.events.ui.PersonPanelSelectionChangedEvent;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.commons.core.LogsCenter;
-
-import java.util.logging.Logger;
-
-/**
- * Panel containing the list of persons.
- */
-public class PersonListPanel extends UiPart {
- private final Logger logger = LogsCenter.getLogger(PersonListPanel.class);
- private static final String FXML = "PersonListPanel.fxml";
- private VBox panel;
- private AnchorPane placeHolderPane;
-
- @FXML
- private ListView personListView;
-
- public PersonListPanel() {
- super();
- }
-
- @Override
- public void setNode(Node node) {
- panel = (VBox) node;
- }
-
- @Override
- public String getFxmlPath() {
- return FXML;
- }
-
- @Override
- public void setPlaceholder(AnchorPane pane) {
- this.placeHolderPane = pane;
- }
-
- public static PersonListPanel load(Stage primaryStage, AnchorPane personListPlaceholder,
- ObservableList personList) {
- PersonListPanel personListPanel =
- UiPartLoader.loadUiPart(primaryStage, personListPlaceholder, new PersonListPanel());
- personListPanel.configure(personList);
- return personListPanel;
- }
-
- private void configure(ObservableList personList) {
- setConnections(personList);
- addToPlaceholder();
- }
-
- private void setConnections(ObservableList personList) {
- personListView.setItems(personList);
- personListView.setCellFactory(listView -> new PersonListViewCell());
- setEventHandlerForSelectionChangeEvent();
- }
-
- private void addToPlaceholder() {
- SplitPane.setResizableWithParent(placeHolderPane, false);
- placeHolderPane.getChildren().add(panel);
- }
-
- private void setEventHandlerForSelectionChangeEvent() {
- personListView.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
- if (newValue != null) {
- logger.fine("Selection in person list panel changed to : '" + newValue + "'");
- raise(new PersonPanelSelectionChangedEvent(newValue));
- }
- });
- }
-
- public void scrollTo(int index) {
- Platform.runLater(() -> {
- personListView.scrollTo(index);
- personListView.getSelectionModel().clearAndSelect(index);
- });
- }
-
- class PersonListViewCell extends ListCell {
-
- public PersonListViewCell() {
- }
-
- @Override
- protected void updateItem(ReadOnlyPerson person, boolean empty) {
- super.updateItem(person, empty);
-
- if (empty || person == null) {
- setGraphic(null);
- setText(null);
- } else {
- setGraphic(PersonCard.load(person, getIndex() + 1).getLayout());
- }
- }
- }
-
-}
diff --git a/src/main/java/seedu/address/MainApp.java b/src/main/java/seedu/gtd/MainApp.java
similarity index 83%
rename from src/main/java/seedu/address/MainApp.java
rename to src/main/java/seedu/gtd/MainApp.java
index 36dc72a74b7a..98d3e7f4c732 100644
--- a/src/main/java/seedu/address/MainApp.java
+++ b/src/main/java/seedu/gtd/MainApp.java
@@ -1,26 +1,25 @@
-package seedu.address;
+package seedu.gtd;
import com.google.common.eventbus.Subscribe;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.Stage;
-import seedu.address.commons.core.Config;
-import seedu.address.commons.core.EventsCenter;
-import seedu.address.commons.core.LogsCenter;
-import seedu.address.commons.core.Version;
-import seedu.address.commons.events.ui.ExitAppRequestEvent;
-import seedu.address.commons.exceptions.DataConversionException;
-import seedu.address.commons.util.StringUtil;
-import seedu.address.logic.Logic;
-import seedu.address.logic.LogicManager;
-import seedu.address.model.*;
-import seedu.address.commons.util.ConfigUtil;
-import seedu.address.storage.Storage;
-import seedu.address.storage.StorageManager;
-import seedu.address.ui.Ui;
-import seedu.address.ui.UiManager;
-
-import java.io.FileNotFoundException;
+import seedu.gtd.commons.core.Config;
+import seedu.gtd.commons.core.EventsCenter;
+import seedu.gtd.commons.core.LogsCenter;
+import seedu.gtd.commons.core.Version;
+import seedu.gtd.commons.events.ui.ExitAppRequestEvent;
+import seedu.gtd.commons.exceptions.DataConversionException;
+import seedu.gtd.commons.util.ConfigUtil;
+import seedu.gtd.commons.util.StringUtil;
+import seedu.gtd.logic.Logic;
+import seedu.gtd.logic.LogicManager;
+import seedu.gtd.model.*;
+import seedu.gtd.storage.Storage;
+import seedu.gtd.storage.StorageManager;
+import seedu.gtd.ui.Ui;
+import seedu.gtd.ui.UiManager;
+
import java.io.IOException;
import java.util.Map;
import java.util.Optional;
@@ -29,6 +28,8 @@
/**
* The main entry point to the application.
*/
+
+//@@author addressbook-level4
public class MainApp extends Application {
private static final Logger logger = LogsCenter.getLogger(MainApp.class);
@@ -45,7 +46,7 @@ public MainApp() {}
@Override
public void init() throws Exception {
- logger.info("=============================[ Initializing AddressBook ]===========================");
+ logger.info("=============================[ Initializing TaskList ]===========================");
super.init();
config = initConfig(getApplicationParameter("config"));
@@ -75,14 +76,14 @@ private Model initModelManager(Storage storage, UserPrefs userPrefs) {
try {
addressBookOptional = storage.readAddressBook();
if(!addressBookOptional.isPresent()){
- logger.info("Data file not found. Will be starting with an empty AddressBook");
+ logger.info("Data file not found. Will be starting with an empty TaskList");
}
initialData = addressBookOptional.orElse(new AddressBook());
} catch (DataConversionException e) {
- logger.warning("Data file not in the correct format. Will be starting with an empty AddressBook");
+ logger.warning("Data file not in the correct format. Will be starting with an empty TaskList");
initialData = new AddressBook();
} catch (IOException e) {
- logger.warning("Problem while reading from the file. . Will be starting with an empty AddressBook");
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
initialData = new AddressBook();
}
@@ -139,7 +140,7 @@ protected UserPrefs initPrefs(Config config) {
"Using default user prefs");
initializedPrefs = new UserPrefs();
} catch (IOException e) {
- logger.warning("Problem while reading from the file. . Will be starting with an empty AddressBook");
+ logger.warning("Problem while reading from the file. . Will be starting with an empty TaskList");
initializedPrefs = new UserPrefs();
}
@@ -159,13 +160,13 @@ private void initEventsCenter() {
@Override
public void start(Stage primaryStage) {
- logger.info("Starting AddressBook " + MainApp.VERSION);
+ logger.info("Starting TaskList " + MainApp.VERSION);
ui.start(primaryStage);
}
@Override
public void stop() {
- logger.info("============================ [ Stopping Address Book ] =============================");
+ logger.info("============================ [ Stopping Task List ] =============================");
ui.stop();
try {
storage.saveUserPrefs(userPrefs);
diff --git a/src/main/java/seedu/address/commons/core/ComponentManager.java b/src/main/java/seedu/gtd/commons/core/ComponentManager.java
similarity index 74%
rename from src/main/java/seedu/address/commons/core/ComponentManager.java
rename to src/main/java/seedu/gtd/commons/core/ComponentManager.java
index 4bc8564e5824..1b0561e20d5c 100644
--- a/src/main/java/seedu/address/commons/core/ComponentManager.java
+++ b/src/main/java/seedu/gtd/commons/core/ComponentManager.java
@@ -1,6 +1,8 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
-import seedu.address.commons.events.BaseEvent;
+import java.util.Set;
+
+import seedu.gtd.commons.events.BaseEvent;
/**
* Base class for *Manager classes
@@ -25,4 +27,9 @@ public ComponentManager(EventsCenter eventsCenter) {
protected void raise(BaseEvent event){
eventsCenter.post(event);
}
+
+ public void updateFilteredListToShowRemoved() {
+ // TODO Auto-generated method stub
+
+ }
}
diff --git a/src/main/java/seedu/address/commons/core/Config.java b/src/main/java/seedu/gtd/commons/core/Config.java
similarity index 90%
rename from src/main/java/seedu/address/commons/core/Config.java
rename to src/main/java/seedu/gtd/commons/core/Config.java
index 6441c9ef20f4..173d2ca8a490 100644
--- a/src/main/java/seedu/address/commons/core/Config.java
+++ b/src/main/java/seedu/gtd/commons/core/Config.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
import java.util.Objects;
import java.util.logging.Level;
@@ -11,11 +11,11 @@ public class Config {
public static final String DEFAULT_CONFIG_FILE = "config.json";
// Config values customizable through config file
- private String appTitle = "Address App";
+ private String appTitle = "Tary";
private Level logLevel = Level.INFO;
private String userPrefsFilePath = "preferences.json";
- private String addressBookFilePath = "data/addressbook.xml";
- private String addressBookName = "MyAddressBook";
+ private String addressBookFilePath = "data/tasklist.xml";
+ private String addressBookName = "MyTaskList";
public Config() {
@@ -92,7 +92,7 @@ public String toString(){
sb.append("\nCurrent log level : " + logLevel);
sb.append("\nPreference file Location : " + userPrefsFilePath);
sb.append("\nLocal data file location : " + addressBookFilePath);
- sb.append("\nAddressBook name : " + addressBookName);
+ sb.append("\nTask List name : " + addressBookName);
return sb.toString();
}
diff --git a/src/main/java/seedu/address/commons/core/EventsCenter.java b/src/main/java/seedu/gtd/commons/core/EventsCenter.java
similarity index 92%
rename from src/main/java/seedu/address/commons/core/EventsCenter.java
rename to src/main/java/seedu/gtd/commons/core/EventsCenter.java
index 9652cd5c227b..2472fab5018b 100644
--- a/src/main/java/seedu/address/commons/core/EventsCenter.java
+++ b/src/main/java/seedu/gtd/commons/core/EventsCenter.java
@@ -1,7 +1,8 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
import com.google.common.eventbus.EventBus;
-import seedu.address.commons.events.BaseEvent;
+
+import seedu.gtd.commons.events.BaseEvent;
import java.util.logging.Logger;
diff --git a/src/main/java/seedu/address/commons/core/GuiSettings.java b/src/main/java/seedu/gtd/commons/core/GuiSettings.java
similarity index 93%
rename from src/main/java/seedu/address/commons/core/GuiSettings.java
rename to src/main/java/seedu/gtd/commons/core/GuiSettings.java
index e157ac8b8679..60e5c48fb297 100644
--- a/src/main/java/seedu/address/commons/core/GuiSettings.java
+++ b/src/main/java/seedu/gtd/commons/core/GuiSettings.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
import java.awt.*;
import java.io.Serializable;
@@ -9,8 +9,8 @@
*/
public class GuiSettings implements Serializable {
- private static final double DEFAULT_HEIGHT = 600;
- private static final double DEFAULT_WIDTH = 740;
+ private static final double DEFAULT_HEIGHT = 768;
+ private static final double DEFAULT_WIDTH = 1024;
private Double windowWidth;
private Double windowHeight;
diff --git a/src/main/java/seedu/address/commons/core/LogsCenter.java b/src/main/java/seedu/gtd/commons/core/LogsCenter.java
similarity index 97%
rename from src/main/java/seedu/address/commons/core/LogsCenter.java
rename to src/main/java/seedu/gtd/commons/core/LogsCenter.java
index 17939bab4975..cdd8671c8dd3 100644
--- a/src/main/java/seedu/address/commons/core/LogsCenter.java
+++ b/src/main/java/seedu/gtd/commons/core/LogsCenter.java
@@ -1,10 +1,10 @@
-package seedu.address.commons.core;
-
-import seedu.address.commons.events.BaseEvent;
+package seedu.gtd.commons.core;
import java.io.IOException;
import java.util.logging.*;
+import seedu.gtd.commons.events.BaseEvent;
+
/**
* Configures and manages loggers and handlers, including their logging level
* Named {@link Logger}s can be obtained from this class
diff --git a/src/main/java/seedu/gtd/commons/core/Messages.java b/src/main/java/seedu/gtd/commons/core/Messages.java
new file mode 100644
index 000000000000..cc9ac463d44f
--- /dev/null
+++ b/src/main/java/seedu/gtd/commons/core/Messages.java
@@ -0,0 +1,14 @@
+package seedu.gtd.commons.core;
+
+/**
+ * Container for user visible messages.
+ */
+public class Messages {
+
+ public static final String MESSAGE_UNKNOWN_COMMAND = "Unknown command";
+ public static final String MESSAGE_INVALID_COMMAND_FORMAT = "Invalid command format! \n%1$s";
+ public static final String START_END_DATE_INVALID_COMMAND_FORMAT = "Invalid start and end date.";
+ public static final String MESSAGE_INVALID_TASK_DISPLAYED_INDEX = "The task index provided is invalid";
+ public static final String MESSAGE_TASKS_LISTED_OVERVIEW = "%1$d tasks listed!";
+
+}
diff --git a/src/main/java/seedu/address/commons/core/UnmodifiableObservableList.java b/src/main/java/seedu/gtd/commons/core/UnmodifiableObservableList.java
similarity index 99%
rename from src/main/java/seedu/address/commons/core/UnmodifiableObservableList.java
rename to src/main/java/seedu/gtd/commons/core/UnmodifiableObservableList.java
index 5c25d8647a8d..924195a6fc45 100644
--- a/src/main/java/seedu/address/commons/core/UnmodifiableObservableList.java
+++ b/src/main/java/seedu/gtd/commons/core/UnmodifiableObservableList.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
import javafx.beans.InvalidationListener;
import javafx.collections.ListChangeListener;
diff --git a/src/main/java/seedu/address/commons/core/Version.java b/src/main/java/seedu/gtd/commons/core/Version.java
similarity index 98%
rename from src/main/java/seedu/address/commons/core/Version.java
rename to src/main/java/seedu/gtd/commons/core/Version.java
index 7ecb85b18f82..90887ef85253 100644
--- a/src/main/java/seedu/address/commons/core/Version.java
+++ b/src/main/java/seedu/gtd/commons/core/Version.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.core;
+package seedu.gtd.commons.core;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
diff --git a/src/main/java/seedu/address/commons/events/BaseEvent.java b/src/main/java/seedu/gtd/commons/events/BaseEvent.java
similarity index 90%
rename from src/main/java/seedu/address/commons/events/BaseEvent.java
rename to src/main/java/seedu/gtd/commons/events/BaseEvent.java
index 723a9c69fbd5..6b1401131171 100644
--- a/src/main/java/seedu/address/commons/events/BaseEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/BaseEvent.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.events;
+package seedu.gtd.commons.events;
public abstract class BaseEvent {
diff --git a/src/main/java/seedu/address/commons/events/model/AddressBookChangedEvent.java b/src/main/java/seedu/gtd/commons/events/model/AddressBookChangedEvent.java
similarity index 54%
rename from src/main/java/seedu/address/commons/events/model/AddressBookChangedEvent.java
rename to src/main/java/seedu/gtd/commons/events/model/AddressBookChangedEvent.java
index 347a8359e0d5..70375597e49f 100644
--- a/src/main/java/seedu/address/commons/events/model/AddressBookChangedEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/model/AddressBookChangedEvent.java
@@ -1,7 +1,7 @@
-package seedu.address.commons.events.model;
+package seedu.gtd.commons.events.model;
-import seedu.address.commons.events.BaseEvent;
-import seedu.address.model.ReadOnlyAddressBook;
+import seedu.gtd.commons.events.BaseEvent;
+import seedu.gtd.model.ReadOnlyAddressBook;
/** Indicates the AddressBook in the model has changed*/
public class AddressBookChangedEvent extends BaseEvent {
@@ -14,6 +14,6 @@ public AddressBookChangedEvent(ReadOnlyAddressBook data){
@Override
public String toString() {
- return "number of persons " + data.getPersonList().size() + ", number of tags " + data.getTagList().size();
+ return "number of tasks " + data.getTaskList().size() + ", number of tags " + data.getTagList().size();
}
}
diff --git a/src/main/java/seedu/address/commons/events/storage/DataSavingExceptionEvent.java b/src/main/java/seedu/gtd/commons/events/storage/DataSavingExceptionEvent.java
similarity index 78%
rename from src/main/java/seedu/address/commons/events/storage/DataSavingExceptionEvent.java
rename to src/main/java/seedu/gtd/commons/events/storage/DataSavingExceptionEvent.java
index f0a0640ee523..1c305683b3cf 100644
--- a/src/main/java/seedu/address/commons/events/storage/DataSavingExceptionEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/storage/DataSavingExceptionEvent.java
@@ -1,6 +1,6 @@
-package seedu.address.commons.events.storage;
+package seedu.gtd.commons.events.storage;
-import seedu.address.commons.events.BaseEvent;
+import seedu.gtd.commons.events.BaseEvent;
/**
* Indicates an exception during a file saving
diff --git a/src/main/java/seedu/address/commons/events/ui/ExitAppRequestEvent.java b/src/main/java/seedu/gtd/commons/events/ui/ExitAppRequestEvent.java
similarity index 70%
rename from src/main/java/seedu/address/commons/events/ui/ExitAppRequestEvent.java
rename to src/main/java/seedu/gtd/commons/events/ui/ExitAppRequestEvent.java
index 9af6194543a3..eaa3a440623d 100644
--- a/src/main/java/seedu/address/commons/events/ui/ExitAppRequestEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/ui/ExitAppRequestEvent.java
@@ -1,6 +1,6 @@
-package seedu.address.commons.events.ui;
+package seedu.gtd.commons.events.ui;
-import seedu.address.commons.events.BaseEvent;
+import seedu.gtd.commons.events.BaseEvent;
/**
* Indicates a request for App termination
diff --git a/src/main/java/seedu/address/commons/events/ui/IncorrectCommandAttemptedEvent.java b/src/main/java/seedu/gtd/commons/events/ui/IncorrectCommandAttemptedEvent.java
similarity index 68%
rename from src/main/java/seedu/address/commons/events/ui/IncorrectCommandAttemptedEvent.java
rename to src/main/java/seedu/gtd/commons/events/ui/IncorrectCommandAttemptedEvent.java
index 991f7ae9fa25..4d34033fd601 100644
--- a/src/main/java/seedu/address/commons/events/ui/IncorrectCommandAttemptedEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/ui/IncorrectCommandAttemptedEvent.java
@@ -1,7 +1,7 @@
-package seedu.address.commons.events.ui;
+package seedu.gtd.commons.events.ui;
-import seedu.address.commons.events.BaseEvent;
-import seedu.address.logic.commands.Command;
+import seedu.gtd.commons.events.BaseEvent;
+import seedu.gtd.logic.commands.Command;
/**
* Indicates an attempt to execute an incorrect command
diff --git a/src/main/java/seedu/address/commons/events/ui/JumpToListRequestEvent.java b/src/main/java/seedu/gtd/commons/events/ui/JumpToListRequestEvent.java
similarity index 68%
rename from src/main/java/seedu/address/commons/events/ui/JumpToListRequestEvent.java
rename to src/main/java/seedu/gtd/commons/events/ui/JumpToListRequestEvent.java
index 0580d27aecf5..6d8263cee5bd 100644
--- a/src/main/java/seedu/address/commons/events/ui/JumpToListRequestEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/ui/JumpToListRequestEvent.java
@@ -1,9 +1,9 @@
-package seedu.address.commons.events.ui;
+package seedu.gtd.commons.events.ui;
-import seedu.address.commons.events.BaseEvent;
+import seedu.gtd.commons.events.BaseEvent;
/**
- * Indicates a request to jump to the list of persons
+ * Indicates a request to jump to the list of tasks
*/
public class JumpToListRequestEvent extends BaseEvent {
diff --git a/src/main/java/seedu/address/commons/events/ui/ShowHelpRequestEvent.java b/src/main/java/seedu/gtd/commons/events/ui/ShowHelpRequestEvent.java
similarity index 70%
rename from src/main/java/seedu/address/commons/events/ui/ShowHelpRequestEvent.java
rename to src/main/java/seedu/gtd/commons/events/ui/ShowHelpRequestEvent.java
index a7e40940b2c7..041fcd3f5b81 100644
--- a/src/main/java/seedu/address/commons/events/ui/ShowHelpRequestEvent.java
+++ b/src/main/java/seedu/gtd/commons/events/ui/ShowHelpRequestEvent.java
@@ -1,6 +1,6 @@
-package seedu.address.commons.events.ui;
+package seedu.gtd.commons.events.ui;
-import seedu.address.commons.events.BaseEvent;
+import seedu.gtd.commons.events.BaseEvent;
/**
* An event requesting to view the help page.
diff --git a/src/main/java/seedu/gtd/commons/events/ui/TaskPanelSelectionChangedEvent.java b/src/main/java/seedu/gtd/commons/events/ui/TaskPanelSelectionChangedEvent.java
new file mode 100644
index 000000000000..27b9264f19cd
--- /dev/null
+++ b/src/main/java/seedu/gtd/commons/events/ui/TaskPanelSelectionChangedEvent.java
@@ -0,0 +1,26 @@
+package seedu.gtd.commons.events.ui;
+
+import seedu.gtd.commons.events.BaseEvent;
+import seedu.gtd.model.task.ReadOnlyTask;
+
+/**
+ * Represents a selection change in the Task List Panel
+ */
+public class TaskPanelSelectionChangedEvent extends BaseEvent {
+
+
+ private final ReadOnlyTask newSelection;
+
+ public TaskPanelSelectionChangedEvent(ReadOnlyTask newSelection){
+ this.newSelection = newSelection;
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName();
+ }
+
+ public ReadOnlyTask getNewSelection() {
+ return newSelection;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/seedu/address/commons/exceptions/DataConversionException.java b/src/main/java/seedu/gtd/commons/exceptions/DataConversionException.java
similarity index 60%
rename from src/main/java/seedu/address/commons/exceptions/DataConversionException.java
rename to src/main/java/seedu/gtd/commons/exceptions/DataConversionException.java
index 1f689bd8e3f9..618900e8919b 100644
--- a/src/main/java/seedu/address/commons/exceptions/DataConversionException.java
+++ b/src/main/java/seedu/gtd/commons/exceptions/DataConversionException.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.exceptions;
+package seedu.gtd.commons.exceptions;
/**
* Represents an error during conversion of data from one format to another
@@ -7,5 +7,9 @@ public class DataConversionException extends Exception {
public DataConversionException(Exception cause) {
super(cause);
}
-
+
+ //@@author A0146130W
+ public DataConversionException(String cause) {
+ super(cause);
+ }
}
diff --git a/src/main/java/seedu/address/commons/exceptions/DuplicateDataException.java b/src/main/java/seedu/gtd/commons/exceptions/DuplicateDataException.java
similarity index 85%
rename from src/main/java/seedu/address/commons/exceptions/DuplicateDataException.java
rename to src/main/java/seedu/gtd/commons/exceptions/DuplicateDataException.java
index 17aa63d5020c..be153162172d 100644
--- a/src/main/java/seedu/address/commons/exceptions/DuplicateDataException.java
+++ b/src/main/java/seedu/gtd/commons/exceptions/DuplicateDataException.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.exceptions;
+package seedu.gtd.commons.exceptions;
/**
* Signals an error caused by duplicate data where there should be none.
diff --git a/src/main/java/seedu/address/commons/exceptions/IllegalValueException.java b/src/main/java/seedu/gtd/commons/exceptions/IllegalValueException.java
similarity index 88%
rename from src/main/java/seedu/address/commons/exceptions/IllegalValueException.java
rename to src/main/java/seedu/gtd/commons/exceptions/IllegalValueException.java
index a473b43bd86f..299a51519440 100644
--- a/src/main/java/seedu/address/commons/exceptions/IllegalValueException.java
+++ b/src/main/java/seedu/gtd/commons/exceptions/IllegalValueException.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.exceptions;
+package seedu.gtd.commons.exceptions;
/**
* Signals that some given data does not fulfill some constraints.
diff --git a/src/main/java/seedu/address/commons/util/AppUtil.java b/src/main/java/seedu/gtd/commons/util/AppUtil.java
similarity index 81%
rename from src/main/java/seedu/address/commons/util/AppUtil.java
rename to src/main/java/seedu/gtd/commons/util/AppUtil.java
index 649cc19aaeda..d8e0aea573d9 100644
--- a/src/main/java/seedu/address/commons/util/AppUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/AppUtil.java
@@ -1,7 +1,7 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import javafx.scene.image.Image;
-import seedu.address.MainApp;
+import seedu.gtd.MainApp;
/**
* A container for App specific utility functions
diff --git a/src/main/java/seedu/address/commons/util/CollectionUtil.java b/src/main/java/seedu/gtd/commons/util/CollectionUtil.java
similarity index 96%
rename from src/main/java/seedu/address/commons/util/CollectionUtil.java
rename to src/main/java/seedu/gtd/commons/util/CollectionUtil.java
index fde8394f31e5..0fa06a43a0a5 100644
--- a/src/main/java/seedu/address/commons/util/CollectionUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/CollectionUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import java.util.Collection;
import java.util.HashSet;
diff --git a/src/main/java/seedu/address/commons/util/ConfigUtil.java b/src/main/java/seedu/gtd/commons/util/ConfigUtil.java
similarity index 86%
rename from src/main/java/seedu/address/commons/util/ConfigUtil.java
rename to src/main/java/seedu/gtd/commons/util/ConfigUtil.java
index af42e03df06c..3c9472adf2fa 100644
--- a/src/main/java/seedu/address/commons/util/ConfigUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/ConfigUtil.java
@@ -1,14 +1,14 @@
-package seedu.address.commons.util;
-
-import seedu.address.commons.core.Config;
-import seedu.address.commons.core.LogsCenter;
-import seedu.address.commons.exceptions.DataConversionException;
+package seedu.gtd.commons.util;
import java.io.File;
import java.io.IOException;
import java.util.Optional;
import java.util.logging.Logger;
+import seedu.gtd.commons.core.Config;
+import seedu.gtd.commons.core.LogsCenter;
+import seedu.gtd.commons.exceptions.DataConversionException;
+
/**
* A class for accessing the Config File.
*/
@@ -55,8 +55,9 @@ public static Optional readConfig(String configFilePath) throws DataConv
public static void saveConfig(Config config, String configFilePath) throws IOException {
assert config != null;
assert configFilePath != null;
-
+ logger.info("Saving config: \n" + config);
FileUtil.serializeObjectToJsonFile(new File(configFilePath), config);
+ logger.info("Config file saved to " + configFilePath);
}
}
diff --git a/src/main/java/seedu/address/commons/util/FileUtil.java b/src/main/java/seedu/gtd/commons/util/FileUtil.java
similarity index 98%
rename from src/main/java/seedu/address/commons/util/FileUtil.java
rename to src/main/java/seedu/gtd/commons/util/FileUtil.java
index ca8221250de4..97ce353111a0 100644
--- a/src/main/java/seedu/address/commons/util/FileUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/FileUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import java.io.File;
import java.io.IOException;
diff --git a/src/main/java/seedu/address/commons/util/FxViewUtil.java b/src/main/java/seedu/gtd/commons/util/FxViewUtil.java
similarity index 92%
rename from src/main/java/seedu/address/commons/util/FxViewUtil.java
rename to src/main/java/seedu/gtd/commons/util/FxViewUtil.java
index 900efa6bf5c3..013b7b2fcb3c 100644
--- a/src/main/java/seedu/address/commons/util/FxViewUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/FxViewUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import javafx.scene.Node;
import javafx.scene.layout.AnchorPane;
diff --git a/src/main/java/seedu/address/commons/util/JsonUtil.java b/src/main/java/seedu/gtd/commons/util/JsonUtil.java
similarity index 98%
rename from src/main/java/seedu/address/commons/util/JsonUtil.java
rename to src/main/java/seedu/gtd/commons/util/JsonUtil.java
index 80b67de5b7e8..02f872e76492 100644
--- a/src/main/java/seedu/address/commons/util/JsonUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/JsonUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
diff --git a/src/main/java/seedu/address/commons/util/StringUtil.java b/src/main/java/seedu/gtd/commons/util/StringUtil.java
similarity index 96%
rename from src/main/java/seedu/address/commons/util/StringUtil.java
rename to src/main/java/seedu/gtd/commons/util/StringUtil.java
index 2e94740456a6..4fbf3b94cdbf 100644
--- a/src/main/java/seedu/address/commons/util/StringUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/StringUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import java.io.PrintWriter;
import java.io.StringWriter;
diff --git a/src/main/java/seedu/address/commons/util/UrlUtil.java b/src/main/java/seedu/gtd/commons/util/UrlUtil.java
similarity index 94%
rename from src/main/java/seedu/address/commons/util/UrlUtil.java
rename to src/main/java/seedu/gtd/commons/util/UrlUtil.java
index 6bbab52b9840..7c19154a2372 100644
--- a/src/main/java/seedu/address/commons/util/UrlUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/UrlUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import java.net.URL;
diff --git a/src/main/java/seedu/address/commons/util/XmlUtil.java b/src/main/java/seedu/gtd/commons/util/XmlUtil.java
similarity index 98%
rename from src/main/java/seedu/address/commons/util/XmlUtil.java
rename to src/main/java/seedu/gtd/commons/util/XmlUtil.java
index 2087e7628a1d..afa15a030399 100644
--- a/src/main/java/seedu/address/commons/util/XmlUtil.java
+++ b/src/main/java/seedu/gtd/commons/util/XmlUtil.java
@@ -1,4 +1,4 @@
-package seedu.address.commons.util;
+package seedu.gtd.commons.util;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
diff --git a/src/main/java/seedu/address/logic/Logic.java b/src/main/java/seedu/gtd/logic/Logic.java
similarity index 58%
rename from src/main/java/seedu/address/logic/Logic.java
rename to src/main/java/seedu/gtd/logic/Logic.java
index 4df1bc65cabb..e5efa7d6d694 100644
--- a/src/main/java/seedu/address/logic/Logic.java
+++ b/src/main/java/seedu/gtd/logic/Logic.java
@@ -1,8 +1,8 @@
-package seedu.address.logic;
+package seedu.gtd.logic;
import javafx.collections.ObservableList;
-import seedu.address.logic.commands.CommandResult;
-import seedu.address.model.person.ReadOnlyPerson;
+import seedu.gtd.logic.commands.CommandResult;
+import seedu.gtd.model.task.ReadOnlyTask;
/**
* API of the Logic component
@@ -15,7 +15,7 @@ public interface Logic {
*/
CommandResult execute(String commandText);
- /** Returns the filtered list of persons */
- ObservableList getFilteredPersonList();
+ /** Returns the filtered list of tasks */
+ ObservableList getFilteredTaskList();
}
diff --git a/src/main/java/seedu/address/logic/LogicManager.java b/src/main/java/seedu/gtd/logic/LogicManager.java
similarity index 57%
rename from src/main/java/seedu/address/logic/LogicManager.java
rename to src/main/java/seedu/gtd/logic/LogicManager.java
index ce4dc1903cff..f6602d7afd4e 100644
--- a/src/main/java/seedu/address/logic/LogicManager.java
+++ b/src/main/java/seedu/gtd/logic/LogicManager.java
@@ -1,14 +1,14 @@
-package seedu.address.logic;
+package seedu.gtd.logic;
-import javafx.collections.ObservableList;
-import seedu.address.commons.core.ComponentManager;
-import seedu.address.commons.core.LogsCenter;
-import seedu.address.logic.commands.Command;
-import seedu.address.logic.commands.CommandResult;
-import seedu.address.logic.parser.Parser;
-import seedu.address.model.Model;
-import seedu.address.model.person.ReadOnlyPerson;
-import seedu.address.storage.Storage;
+import seedu.gtd.commons.core.ComponentManager;
+import seedu.gtd.commons.core.LogsCenter;
+import seedu.gtd.commons.core.UnmodifiableObservableList;
+import seedu.gtd.logic.commands.Command;
+import seedu.gtd.logic.commands.CommandResult;
+import seedu.gtd.logic.parser.Parser;
+import seedu.gtd.model.Model;
+import seedu.gtd.model.task.ReadOnlyTask;
+import seedu.gtd.storage.Storage;
import java.util.logging.Logger;
@@ -35,7 +35,7 @@ public CommandResult execute(String commandText) {
}
@Override
- public ObservableList getFilteredPersonList() {
- return model.getFilteredPersonList();
+ public UnmodifiableObservableList getFilteredTaskList() {
+ return model.getFilteredTaskList();
}
}
diff --git a/src/main/java/seedu/gtd/logic/commands/AddCommand.java b/src/main/java/seedu/gtd/logic/commands/AddCommand.java
new file mode 100644
index 000000000000..3e05f5769132
--- /dev/null
+++ b/src/main/java/seedu/gtd/logic/commands/AddCommand.java
@@ -0,0 +1,64 @@
+package seedu.gtd.logic.commands;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import seedu.gtd.commons.exceptions.IllegalValueException;
+import seedu.gtd.model.task.*;
+import seedu.gtd.model.tag.Tag;
+import seedu.gtd.model.tag.UniqueTagList;
+
+/**
+ * Adds a task to the task list.
+ */
+//@@author A0130677A
+public class AddCommand extends Command {
+
+ public static final String COMMAND_WORD = "add";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Adds a task to the GTD. "
+ + "Parameters: NAME [s/STARTDATE d/DUEDATE a/ADDRESS p/PRIORITY t/TAGS]...\n"
+ + "All parameters except name is optional.\n"
+ + "Example: " + COMMAND_WORD
+ + " Do CS2103 Tutorial 4 d/noon a/NUS p/3 t/CS2103 tutorial fun";
+
+ public static final String MESSAGE_SUCCESS = "New task added: %1$s";
+ public static final String MESSAGE_DUPLICATE_TASK = "This task already exists in the task list";
+
+ private final Task toAdd;
+
+ /**
+ * Convenience constructor using raw values.
+ *
+ * @throws IllegalValueException if any of the raw values are invalid
+ */
+ public AddCommand(String name, String startDate, String dueDate, String address, String priority, Set tags)
+ throws IllegalValueException {
+ final Set tagSet = new HashSet<>();
+ for (String tagName : tags) {
+ tagSet.add(new Tag(tagName));
+ }
+ this.toAdd = new Task(
+ new Name(name),
+ new DueDate(startDate),
+ new DueDate(dueDate),
+ new Address(address),
+ new Priority(priority),
+ new UniqueTagList(tagSet)
+ );
+ }
+
+ //@@author addressbook-level4
+ @Override
+ public CommandResult execute() {
+ assert model != null;
+ try {
+ model.addTask(toAdd);
+ return new CommandResult(String.format(MESSAGE_SUCCESS, toAdd));
+ } catch (UniqueTaskList.DuplicateTaskException e) {
+ return new CommandResult(MESSAGE_DUPLICATE_TASK);
+ }
+
+ }
+
+}
diff --git a/src/main/java/seedu/address/logic/commands/ClearCommand.java b/src/main/java/seedu/gtd/logic/commands/ClearCommand.java
similarity index 53%
rename from src/main/java/seedu/address/logic/commands/ClearCommand.java
rename to src/main/java/seedu/gtd/logic/commands/ClearCommand.java
index 522d57189f51..7689aeadc00c 100644
--- a/src/main/java/seedu/address/logic/commands/ClearCommand.java
+++ b/src/main/java/seedu/gtd/logic/commands/ClearCommand.java
@@ -1,6 +1,6 @@
-package seedu.address.logic.commands;
+package seedu.gtd.logic.commands;
-import seedu.address.model.AddressBook;
+import seedu.gtd.model.AddressBook;
/**
* Clears the address book.
@@ -8,7 +8,8 @@
public class ClearCommand extends Command {
public static final String COMMAND_WORD = "clear";
- public static final String MESSAGE_SUCCESS = "Address book has been cleared!";
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ": Clears the Task List.";
+ public static final String MESSAGE_SUCCESS = "Task List has been cleared!";
public ClearCommand() {}
@@ -16,7 +17,7 @@ public ClearCommand() {}
@Override
public CommandResult execute() {
assert model != null;
- model.resetData(AddressBook.getEmptyAddressBook());
+ model.clearTaskList();
return new CommandResult(MESSAGE_SUCCESS);
}
}
diff --git a/src/main/java/seedu/address/logic/commands/Command.java b/src/main/java/seedu/gtd/logic/commands/Command.java
similarity index 67%
rename from src/main/java/seedu/address/logic/commands/Command.java
rename to src/main/java/seedu/gtd/logic/commands/Command.java
index 7c0ba2fd0161..187f0883b3c8 100644
--- a/src/main/java/seedu/address/logic/commands/Command.java
+++ b/src/main/java/seedu/gtd/logic/commands/Command.java
@@ -1,9 +1,9 @@
-package seedu.address.logic.commands;
+package seedu.gtd.logic.commands;
-import seedu.address.commons.core.EventsCenter;
-import seedu.address.commons.core.Messages;
-import seedu.address.commons.events.ui.IncorrectCommandAttemptedEvent;
-import seedu.address.model.Model;
+import seedu.gtd.commons.core.EventsCenter;
+import seedu.gtd.commons.core.Messages;
+import seedu.gtd.commons.events.ui.IncorrectCommandAttemptedEvent;
+import seedu.gtd.model.Model;
/**
* Represents a command with hidden internal logic and the ability to be executed.
@@ -12,13 +12,13 @@ public abstract class Command {
protected Model model;
/**
- * Constructs a feedback message to summarise an operation that displayed a listing of persons.
+ * Constructs a feedback message to summarise an operation that displayed a listing of tasks.
*
* @param displaySize used to generate summary
- * @return summary message for persons displayed
+ * @return summary message for tasks displayed
*/
- public static String getMessageForPersonListShownSummary(int displaySize) {
- return String.format(Messages.MESSAGE_PERSONS_LISTED_OVERVIEW, displaySize);
+ public static String getMessageForTaskListShownSummary(int displaySize) {
+ return String.format(Messages.MESSAGE_TASKS_LISTED_OVERVIEW, displaySize);
}
/**
diff --git a/src/main/java/seedu/address/logic/commands/CommandResult.java b/src/main/java/seedu/gtd/logic/commands/CommandResult.java
similarity index 87%
rename from src/main/java/seedu/address/logic/commands/CommandResult.java
rename to src/main/java/seedu/gtd/logic/commands/CommandResult.java
index f46f2f31353e..515511706425 100644
--- a/src/main/java/seedu/address/logic/commands/CommandResult.java
+++ b/src/main/java/seedu/gtd/logic/commands/CommandResult.java
@@ -1,4 +1,4 @@
-package seedu.address.logic.commands;
+package seedu.gtd.logic.commands;
/**
* Represents the result of a command execution.
diff --git a/src/main/java/seedu/gtd/logic/commands/DeleteCommand.java b/src/main/java/seedu/gtd/logic/commands/DeleteCommand.java
new file mode 100644
index 000000000000..4ed6c87e80b4
--- /dev/null
+++ b/src/main/java/seedu/gtd/logic/commands/DeleteCommand.java
@@ -0,0 +1,50 @@
+package seedu.gtd.logic.commands;
+
+import seedu.gtd.commons.core.Messages;
+import seedu.gtd.commons.core.UnmodifiableObservableList;
+import seedu.gtd.model.task.ReadOnlyTask;
+import seedu.gtd.model.task.UniqueTaskList.TaskNotFoundException;
+
+/**
+ * Deletes a task identified using it's last displayed index from the address book.
+ */
+public class DeleteCommand extends Command {
+
+ public static final String COMMAND_WORD = "delete";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD
+ + ": Deletes the task identified by the index number used in the last task listing.\n"
+ + "Parameters: INDEX (must be a positive integer)\n"
+ + "Example: " + COMMAND_WORD + " 1";
+
+ public static final String MESSAGE_DELETE_TASK_SUCCESS = "Deleted Task: %1$s";
+
+ public final int targetIndex;
+
+ public DeleteCommand(int targetIndex) {
+ this.targetIndex = targetIndex;
+ }
+
+
+ @Override
+ public CommandResult execute() {
+
+ UnmodifiableObservableList lastShownList = model.getFilteredTaskList();
+
+ if (lastShownList.size() < targetIndex) {
+ indicateAttemptToExecuteIncorrectCommand();
+ return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+ }
+
+ ReadOnlyTask taskToDelete = lastShownList.get(targetIndex - 1);
+
+ try {
+ model.deleteTask(taskToDelete);
+ } catch (TaskNotFoundException pnfe) {
+ assert false : "The target task cannot be missing";
+ }
+
+ return new CommandResult(String.format(MESSAGE_DELETE_TASK_SUCCESS, taskToDelete));
+ }
+
+}
diff --git a/src/main/java/seedu/gtd/logic/commands/DoneCommand.java b/src/main/java/seedu/gtd/logic/commands/DoneCommand.java
new file mode 100644
index 000000000000..9b0cc1a597b3
--- /dev/null
+++ b/src/main/java/seedu/gtd/logic/commands/DoneCommand.java
@@ -0,0 +1,72 @@
+package seedu.gtd.logic.commands;
+
+import seedu.gtd.commons.core.Messages;
+import seedu.gtd.commons.core.UnmodifiableObservableList;
+import seedu.gtd.commons.exceptions.IllegalValueException;
+import seedu.gtd.model.task.ReadOnlyTask;
+import seedu.gtd.model.task.Task;
+import seedu.gtd.model.task.UniqueTaskList.TaskNotFoundException;
+
+/**
+ * Mark a task as done, identified using it's last displayed index from the address book.
+ */
+
+
+//@@author A0130677A
+public class DoneCommand extends Command {
+
+ public static final String COMMAND_WORD = "done";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD
+ + ": Marks a task as done, by the index number used in the last task listing.\n"
+ + "Parameters: INDEX (must be a positive integer)\n"
+ + "Example: " + COMMAND_WORD + " 1";
+
+ public static final String MESSAGE_DONE_TASK_SUCCESS = "Done Task: %1$s";
+
+ public final int targetIndex;
+
+ public DoneCommand(int targetIndex) {
+ this.targetIndex = targetIndex;
+ }
+
+
+ @Override
+ public CommandResult execute() {
+
+ UnmodifiableObservableList lastShownList = model.getFilteredTaskList();
+
+ if (lastShownList.size() < targetIndex) {
+ indicateAttemptToExecuteIncorrectCommand();
+ return new CommandResult(Messages.MESSAGE_INVALID_TASK_DISPLAYED_INDEX);
+ }
+
+ ReadOnlyTask toEdit = lastShownList.get(targetIndex-1);
+ Task taskToUpdate = new Task(toEdit);
+
+ try {
+ taskToUpdate = updateTask(taskToUpdate, "done", "true");
+ } catch (IllegalValueException ive) {
+ return new CommandResult(ive.getMessage());
+ }
+
+ assert model != null;
+ try {
+ System.out.println("in donecommand.java");
+ System.out.println(taskToUpdate.getName() + " " + taskToUpdate.getisDone());
+ System.out.println("index at donecommand:" + targetIndex);
+ model.doneTask(targetIndex-1, taskToUpdate);
+
+ } catch (TaskNotFoundException e) {
+ assert false : "The target task cannot be missing";
+ }
+ return new CommandResult(String.format(MESSAGE_DONE_TASK_SUCCESS, taskToUpdate));
+
+ }
+
+ private Task updateTask(Task taskToUpdate, String detailType, String newDetail) throws IllegalValueException {
+ taskToUpdate.edit(detailType, newDetail);
+ return taskToUpdate;
+ }
+
+}
diff --git a/src/main/java/seedu/gtd/logic/commands/EditCommand.java b/src/main/java/seedu/gtd/logic/commands/EditCommand.java
new file mode 100644
index 000000000000..5815bc903698
--- /dev/null
+++ b/src/main/java/seedu/gtd/logic/commands/EditCommand.java
@@ -0,0 +1,72 @@
+package seedu.gtd.logic.commands;
+
+import java.util.Hashtable;
+import java.util.Set;
+
+import seedu.gtd.commons.core.Messages;
+import seedu.gtd.commons.core.UnmodifiableObservableList;
+import seedu.gtd.commons.exceptions.IllegalValueException;
+import seedu.gtd.model.task.ReadOnlyTask;
+import seedu.gtd.model.task.Task;
+import seedu.gtd.model.task.UniqueTaskList.TaskNotFoundException;
+
+//@@author A0146130W
+ /**
+ * Adds a task to the address book.
+ */
+ public class EditCommand extends Command {
+
+ public static final String COMMAND_WORD = "edit";
+
+ public static final String MESSAGE_USAGE = COMMAND_WORD + ":\n"
+ + "Edits the task identified by the index number used in the last task listing.\n\t"
+ + "Parameters: [INDEX] (must be a positive integer) prefix/[NEW DETAIL]\n\t"
+ + "Example: " + COMMAND_WORD
+ + " 1 p/3";
+
+ public static final String MESSAGE_EDIT_TASK_SUCCESS = "Task updated: %1$s";
+
+ private int targetIndex;
+ private Hashtable