[T7][T15-B4]

.project

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>addressbook-level4</name>
-	<comment>Project addressbook-level4 created by Buildship.</comment>
+	<name>Phase B team v5</name>
+	<comment>Project taskManagerProject created by Buildship.</comment>
 	<projects>
 	</projects>
 	<buildSpec>
@@ -15,35 +15,9 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
-		<buildCommand>
-			<name>net.sf.eclipsecs.core.CheckstyleBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>net.sf.eclipsecs.core.CheckstyleNature</nature>
 	</natures>
-	<filteredResources>
-		<filter>
-			<id>1476898072165</id>
-			<name></name>
-			<type>26</type>
-			<matcher>
-				<id>org.eclipse.ui.ide.multiFilter</id>
-				<arguments>1.0-projectRelativePath-matches-false-false-build</arguments>
-			</matcher>
-		</filter>
-		<filter>
-			<id>1476898072188</id>
-			<name></name>
-			<type>26</type>
-			<matcher>
-				<id>org.eclipse.ui.ide.multiFilter</id>
-				<arguments>1.0-projectRelativePath-matches-false-false-.gradle</arguments>
-			</matcher>
-		</filter>
-	</filteredResources>
 </projectDescription>

.travis.yml

@@ -5,7 +5,7 @@ matrix:
 
 script: >-
     ./config/travis/run-checks.sh &&
-    travis_retry ./gradlew clean checkstyleMain checkstyleTest headless allTests coverage coveralls
+    travis_retry ./gradlew clean headless allTests coverage coveralls
 
 before_install:
           - "export DISPLAY=:99.0"

README.md

@@ -1,36 +1,26 @@
-# Address Book (Level 4)
+# TaskIt
 
-[![Build Status](https://travis-ci.org/se-edu/addressbook-level4.svg?branch=master)](https://travis-ci.org/se-edu/addressbook-level4)
-[![Build status](https://ci.appveyor.com/api/projects/status/3boko2x2vr5cc3w2?svg=true)](https://ci.appveyor.com/project/damithc/addressbook-level4)
-[![Coverage Status](https://coveralls.io/repos/github/se-edu/addressbook-level4/badge.svg?branch=master)](https://coveralls.io/github/se-edu/addressbook-level4?branch=master)
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/fc0b7775cf7f4fdeaf08776f3d8e364a)](https://www.codacy.com/app/damith/addressbook-level4?utm_source=github.com&utm_medium=referral&utm_content=se-edu/addressbook-level4&utm_campaign=Badge_Grade)
+[![Build Status](https://travis-ci.org/CS2103JAN2017-T15-B4/main.svg?branch=master)](https://travis-ci.org/CS2103JAN2017-T15-B4/main)
+[![Coverage Status](https://coveralls.io/repos/github/CS2103JAN2017-T15-B4/main/badge.svg?branch=master)](https://coveralls.io/github/CS2103JAN2017-T15-B4/main?branch=master)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/5a71bb34f16148cfbae7c43bf8067b78)](https://www.codacy.com/app/fanyiii/main?utm_source=github.com&utm_medium=referral&utm_content=CS2103JAN2017-T15-B4/main&utm_campaign=Badge_Grade)
 
-<img src="docs/images/Ui.png" width="600"><br>
+<img src="docs/images/Ui.jpeg" width="600"><br>
 
-* This is a desktop Address Book application. It has a GUI but most of the user interactions happen using
+* TaskIt is a useful and effective task manager app developed by us with the hope to help students and 
+  working adults to better manage their hectic schedule.
+* This is a desktop task manager 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)
 * [Developer Guide](docs/DeveloperGuide.md)
-* [Learning Outcomes](docs/LearningOutcomes.md)
 * [About Us](docs/AboutUs.md)
 * [Contact Us](docs/ContactUs.md)
 
-
 #### Acknowledgements
 
 * Some parts of this sample application were inspired by the excellent
   [Java FX tutorial](http://code.makery.ch/library/javafx-8-tutorial/) by *Marco Jakob*.
-
+* This was adapted from [address book level 4](https://github.com/nus-cs2103-AY1617S2/addressbook-level4/).
 
 #### Licence : [MIT](LICENSE)

build.gradle

@@ -34,12 +34,13 @@ allprojects {
     // This part is similar to global variables
     // Access them by using double-quoted strings (GStrings) and referencing by $ e.g. "Variable contains $Variable"
     project.ext {
+    	nattyVersion = '0.11'
         controlsFxVersion = '8.40.11'
         guavaVersion = '19.0'
         jacksonVersion = '2.7.0'
         jacksonDataTypeVersion = '2.7.4'
         junitVersion = '4.12'
-        testFxVersion = '4.0.+'
+        testFxVersion = '4.0.5-alpha'
         monocleVersion = '1.8.0_20'
         checkstyleVersion = '7.1.2'
 
@@ -63,6 +64,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:$nattyVersion"
 
         testCompile "junit:junit:$junitVersion"
         testCompile "org.testfx:testfx-core:$testFxVersion"

collated/main/A0097141H.md

@@ -0,0 +1,259 @@
+# A0097141H
+###### /java/seedu/taskit/logic/commands/FindCommand.java
+``` java
+/**
+ * Finds and lists all tasks in database 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 tasks 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 + " SWE project";
+
+    private final Set<String> keywords;
+
+    public FindCommand(Set<String> keywords) {
+        this.keywords = keywords;
+    }
+
+    @Override
+    public CommandResult execute() {
+        model.updateFilteredTaskList(keywords);
+        return new CommandResult(getMessageForTaskListShownSummary(model.getFilteredTaskList().size()));
+    }
+
+```
+###### /java/seedu/taskit/logic/parser/FindCommandParser.java
+``` java
+/**
+ * Parses input arguments and creates a new FindCommand object
+ */
+public class FindCommandParser {
+
+    /**
+     * Parses the given {@code String} of arguments in the context of the FindCommand
+     * and returns an FindCommand object for execution.
+     */
+    public Command parse(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));
+        }
+
+        String keywords = matcher.group("keywords");
+        final String[] groupedKeywords = parseKeywords(keywords);
+        final Set<String> keywordSet = new HashSet<>(Arrays.asList(groupedKeywords));
+
+        return new FindCommand(keywordSet);
+    }
+
+
+```
+###### /java/seedu/taskit/logic/parser/FindCommandParser.java
+``` java
+    /**
+     * Method to separate keywords by whitespace or double inverted commas
+     * Assume only 1 set of wrapped keywords are allowed.
+     * @param matcher
+     * @return String[] keywords of
+     */
+    private String[] parseKeywords(String str){
+        String[] keywords = {"keyword"}; //will eventually be overridden
+
+        String keywordsStr = str;
+
+        int[] invCommaIdx = findInvCommasIndexes(keywordsStr);
+        int idxOpenInvComma =	 invCommaIdx[0];
+        int idxCloseInvComma = 	 invCommaIdx[1];
+
+        if(idxOpenInvComma < idxCloseInvComma){ //found a pair of inverted commas!
+            //extract inverted commas
+            keywords[0] = keywordsStr.substring(idxOpenInvComma+1, idxCloseInvComma);
+
+            //create new substring by removing keywords in inverted commas
+            String subStrKeywords = keywordsStr.replace(keywordsStr.substring(idxOpenInvComma,idxCloseInvComma+1), "");
+
+            //if subStrKeywords is not empty string
+            if(!subStrKeywords.trim().equals("")){
+                String[] keywordsToAdd = subStrKeywords.trim().split("\\s+");
+                keywords = concatStringArrays(keywords, keywordsToAdd);
+            }
+        } else{//invalid or don't have inverted commas, just split normally
+            keywords = keywordsStr.split("\\s+");
+        }
+        return keywords;
+    }
+
+```
+###### /java/seedu/taskit/logic/parser/FindCommandParser.java
+``` java
+    /**
+     * returns indexes of occurrences of '\"'
+     * @param str
+     * @return int[] {openInvCommaIndex,closeInvCommaIndex,invCommaCount}
+     * invCommaCount not in use for now, but future releases maybe
+     */
+    private int[] findInvCommasIndexes(String str){
+
+        int[] idx = {0,0,0};
+
+        int idxOpenInvComma = 0;
+        int idxCloseInvComma = 0;
+        boolean foundInvComma = false;
+
+        for (int i=0;i<str.length();i++){
+            if (str.charAt(i) == '\"'){
+                if(!foundInvComma){
+                    idxOpenInvComma = i;
+                    foundInvComma = true;
+                }else{
+                    //found a matching inverted comma
+                    idxCloseInvComma = i;
+                    foundInvComma = false;
+                }
+                idx[2]++;
+            }
+        }
+        idx[0] = idxOpenInvComma;
+        idx[1] = idxCloseInvComma;
+        return idx;
+    }
+
+```
+###### /java/seedu/taskit/logic/parser/FindCommandParser.java
+``` java
+    /**
+     * simple method to return a String[] array based on 2 String[] arrays
+     * @param strArr1
+     * @param strArr2
+     * @return
+     */
+    private String[] concatStringArrays(String[] strArr1, String[] strArr2){
+
+        Object[] objArr = ArrayUtils.addAll(strArr1, strArr2);
+        String[] keywords = Arrays.copyOf(objArr, objArr.length, String[].class);
+
+        return keywords;
+    }
+
+}
+```
+###### /java/seedu/taskit/model/ModelManager.java
+``` java
+    private class NameQualifier implements Qualifier {
+        private Set<String> nameKeyWords;
+
+        NameQualifier(Set<String> nameKeyWords) {
+            this.nameKeyWords = nameKeyWords;
+        }
+
+        @Override
+        public boolean run(ReadOnlyTask task) {
+
+
+          String[] monthsArr = {"january", "jan", "february", "feb", "march", "mar", "april", "apr", "may", "june", "jun",
+                      "july", "jul", "august", "aug", "september", "sept", "sep", "october", "oct",
+                      "november", "nov", "december", "dec"};
+          ArrayList<String> months = new ArrayList<String>() ;
+          Collections.addAll(months, monthsArr);
+          //filter by date to see if searching for date
+
+
+
+          return
+              nameKeyWords.stream()
+                    .filter(keyword -> StringUtil.containsWordIgnoreCase(task.toStringTitleTagAndDateList(), keyword.toLowerCase()))
+                    .findAny()
+                    .isPresent() |
+                    nameKeyWords.stream()
+                    .filter(keyword -> task.toStringTitleTagAndDateList().contains(keyword.toLowerCase()))
+                    .findAny()
+                   .isPresent() |
+
+                    //this is to find if keywords match dates
+
+               nameKeyWords.stream()
+                    .filter(k -> months.contains(k.toLowerCase()))
+                    .filter(k -> {
+                  try {
+                    return (new Date(k)).isMonthEqualsMonth(task.getEnd());
+                  } catch (IllegalValueException | NullPointerException e1) {
+                    //e1.printStackTrace();
+                    return false;
+                  }
+                })
+                    .findAny()
+                    .isPresent() |
+
+                    nameKeyWords.stream()
+                    .filter(keyword -> {
+            try {
+              return task.getEnd().isDateEqualsDate(new Date(keyword)) | task.getStart().isDateEqualsDate(new Date(keyword));
+            } catch (IllegalValueException e) {
+              return false;
+            }
+          })
+                    .findAny()
+                    .isPresent()
+                    ;
+        }
+
+        @Override
+        public String toString() {
+            return "name=" + String.join(", ", nameKeyWords);
+        }
+    }
+
+```
+###### /java/seedu/taskit/model/task/Date.java
+``` java
+    public boolean isDateEqualsDate(Date other) {
+
+      return date != null && DateUtils.isSameDay(date, other.date);
+    }
+
+    public boolean isMonthEqualsMonth(Date other) {
+      Calendar c1 = Calendar.getInstance();
+      c1.setTime(date);
+      Calendar c2 = Calendar.getInstance();
+      c2.setTime(other.date);
+
+      return date != null && c1.get(Calendar.MONTH)==c2.get(Calendar.MONTH);
+    }
+
+    @Override
+    public int hashCode() {
+        return date.hashCode();
+    }
+
+}
+```
+###### /java/seedu/taskit/model/task/ReadOnlyTask.java
+``` java
+    /**
+     * Stringifies title and tags
+     * @return lowercase String with title and tags for easy string matching
+     */
+
+    default String toStringTitleTagAndDateList() {
+      String titleTagAndDateString = getTitle().title + " ";
+      final StringBuilder builder = new StringBuilder();
+      builder.append(getTitle()).append(" ");
+      builder.append(getStart()).append(" ");
+      builder.append(getEnd()).append(" ");
+      getTags().iterator().forEachRemaining(builder::append);
+
+      titleTagAndDateString = builder.toString();
+      titleTagAndDateString = titleTagAndDateString.replace('[', ' ').replace(']', ' ');
+
+      return titleTagAndDateString.toLowerCase();
+    }
+
+}
+
+```