Merge branch 'master' into support-recurring-events

# Conflicts:
#	src/main/java/seedu/agendum/logic/parser/Parser.java
#	src/main/java/seedu/agendum/model/ModelManager.java

collated/main/A0003878Y.md

@@ -0,0 +1,188 @@
+# A0003878Y
+###### \java\seedu\agendum\logic\commands\AddCommand.java
+``` java
+    /**
+     * Convenience constructor using name
+     *
+     * @throws IllegalValueException if any of the raw values are invalid
+     */
+    public AddCommand(String name)
+            throws IllegalValueException {
+        this.toAdd = new Task(
+                new Name(name)
+        );
+    }
+
+    /**
+     * Convenience constructor using name, end datetime
+     *
+     * @throws IllegalValueException if any of the raw values are invalid
+     */
+    public AddCommand(String name, Optional<LocalDateTime> deadlineDate)
+            throws IllegalValueException {
+        this.toAdd = new Task(
+                new Name(name),
+                deadlineDate
+        );
+    }
+
+    /**
+     * Convenience constructor using name, start datetime, end datetime
+     *
+     * @throws IllegalValueException if any of the raw values are invalid
+     */
+    public AddCommand(String name, Optional<LocalDateTime> startDateTime, Optional<LocalDateTime> endDateTime)
+            throws IllegalValueException {
+        this.toAdd = new Task(
+                new Name(name),
+                startDateTime,
+                endDateTime
+        );
+    }
+
+    @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);
+        }
+
+    }
+
+    @Override
+    public String getName() {
+        return COMMAND_WORD;
+    }
+
+    @Override
+    public String getFormat() {
+        return COMMAND_FORMAT;
+    }
+
+    @Override
+    public String getDescription() {
+        return COMMAND_DESCRIPTION;
+    }
+
+}
+
+```
+###### \java\seedu\agendum\logic\parser\Parser.java
+``` java
+    private static final Pattern ADD_ARGS_FORMAT = Pattern.compile("(?:.+?(?=(?:(?:by|from|to)\\s|$)))+?");
+
+    private static final Pattern SCHEDULE_ARGS_FORMAT = Pattern.compile("(?:.+?(?=(?:(?:by|from|to)\\s|$)))+?");
+
+    private static final String ARGS_FROM = "from";
+    private static final String ARGS_BY = "by";
+    private static final String ARGS_TO = "to";
+    private static final String[] TIME_TOKENS = new String[] { ARGS_FROM, ARGS_TO, ARGS_BY };
+
+```
+###### \java\seedu\agendum\logic\parser\Parser.java
+``` java
+    /**
+     * 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) {
+        Matcher matcher = ADD_ARGS_FORMAT.matcher(args.trim());
+        if (!matcher.matches()) {
+            return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE));
+        }
+
+        try {
+            matcher.reset();
+            matcher.find();
+            String taskTitle = matcher.group(0);
+            HashMap<String, Optional<LocalDateTime>> dateTimeMap = new HashMap<>();
+
+            while (matcher.find()) {
+                for (String token : TIME_TOKENS) {
+                    String s = matcher.group(0).toLowerCase();
+                    if (s.startsWith(token)) {
+                        String time = s.substring(token.length(), s.length());
+                        if (DateTimeParser.containsTime(time)) {
+                            dateTimeMap.put(token, DateTimeParser.parseString(time));
+                        } else {
+                            taskTitle = taskTitle + s;
+                        }
+                    }
+                }
+            }
+
+            if (dateTimeMap.containsKey(ARGS_BY)) {
+                return new AddCommand(taskTitle, dateTimeMap.get(ARGS_BY));
+            } else if (dateTimeMap.containsKey(ARGS_FROM) && dateTimeMap.containsKey(ARGS_TO)) {
+                return new AddCommand(taskTitle, dateTimeMap.get(ARGS_FROM), dateTimeMap.get(ARGS_TO));
+            } else if (!dateTimeMap.containsKey(ARGS_FROM) && !dateTimeMap.containsKey(ARGS_TO)
+                    && !dateTimeMap.containsKey(ARGS_BY)) {
+                return new AddCommand(taskTitle);
+            } else {
+                return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+                        AddCommand.MESSAGE_USAGE));
+            }
+        } catch (IllegalValueException ive) {
+            return new IncorrectCommand(ive.getMessage());
+        }
+    }
+
+
+    /**
+     * Parses arguments in the context of the schedule task command.
+     *
+     * @param args full command args string
+     * @return the prepared command
+     */
+    private Command prepareSchedule(String args) {
+        Matcher matcher = ADD_ARGS_FORMAT.matcher(args.trim());
+        if (!matcher.matches()) {
+            return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+                    ScheduleCommand.MESSAGE_USAGE));
+        }
+
+        matcher.reset();
+        matcher.find();
+        Optional<Integer> taskIndex = parseIndex(matcher.group(0));
+        int index = 0;
+        if (taskIndex.isPresent()) {
+            index = taskIndex.get();
+        } else {
+            return new IncorrectCommand(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+                    ScheduleCommand.MESSAGE_USAGE));
+        }
+
+        HashMap<String, Optional<LocalDateTime>> dateTimeMap = new HashMap<>();
+
+        while (matcher.find()) {
+            for (String token : TIME_TOKENS) {
+                String s = matcher.group(0).toLowerCase();
+                if (s.startsWith(token)) {
+                    String time = s.substring(token.length(), s.length());
+                    if (DateTimeParser.containsTime(time)) {
+                        dateTimeMap.put(token, DateTimeParser.parseString(time));
+                    }
+                }
+            }
+        }
+
+        if (dateTimeMap.containsKey(ARGS_BY)) {
+            return new ScheduleCommand(index, Optional.empty(), dateTimeMap.get(ARGS_BY));
+        } else if (dateTimeMap.containsKey(ARGS_FROM) && dateTimeMap.containsKey(ARGS_TO)) {
+            return new ScheduleCommand(index, dateTimeMap.get(ARGS_FROM), dateTimeMap.get(ARGS_TO));
+        } else if (!dateTimeMap.containsKey(ARGS_FROM) && !dateTimeMap.containsKey(ARGS_TO)
+                && !dateTimeMap.containsKey(ARGS_BY)) {
+            return  new ScheduleCommand(index, Optional.empty(), Optional.empty());
+        } else {
+            return new IncorrectCommand(
+                    String.format(MESSAGE_INVALID_COMMAND_FORMAT, ScheduleCommand.MESSAGE_USAGE));
+        }
+    }
+
+
+```