Merge pull request #66 from CS2103-AY1819S1-T13-2/wip/unfavourite

add unfavourite command

src/main/java/seedu/address/logic/commands/FavouriteCommand.java

@@ -11,8 +11,6 @@
 import seedu.address.logic.commands.exceptions.CommandException;
 import seedu.address.model.Model;
 import seedu.address.model.person.Person;
-import seedu.address.model.person.exceptions.DuplicatePersonException;
-import seedu.address.model.person.exceptions.PersonNotFoundException;
 
 /**
  * Favourites an exisiting contact
@@ -27,9 +25,9 @@ public class FavouriteCommand extends Command {
             + "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_FAVOURITE_PERSON_FAIL = "Person already favourited: %1$s";
     public static final String MESSAGE_FAVOURITE_PERSON_SUCCESS = "Added person to favourites: %1$s";
     public static final String MESSAGE_DUPLICATE_PERSON = "This person already exists in the address book.";
-    public static final String MESSAGE_UNFAVOURITE_PERSON_SUCCESS = "Person removed from favourites: %1$s";
     private final Index index;
     /**
      * @param index of the person in the filtered person list to edit
@@ -38,6 +36,7 @@ public FavouriteCommand(Index index) {
         requireNonNull(index);
         this.index = index;
     }
+
     @Override
     public CommandResult execute(Model model, CommandHistory history) throws CommandException {
         List<Person> lastShownList = model.getFilteredPersonList();
@@ -46,36 +45,40 @@ public CommandResult execute(Model model, CommandHistory history) throws Command
         }
         Person personToFavourite = lastShownList.get(index.getZeroBased());
         Person favouritedPerson = createFavouritedPerson(personToFavourite);
-        try {
-            model.favouritePerson(personToFavourite, favouritedPerson);
-        } catch (DuplicatePersonException dpe) {
-            throw new CommandException(MESSAGE_DUPLICATE_PERSON);
-        } catch (PersonNotFoundException pnfe) {
-            throw new AssertionError("The target person cannot be missing");
-        }
+
+        model.favouritePerson(personToFavourite, favouritedPerson);
+
         model.updateFilteredPersonList(PREDICATE_SHOW_ALL_PERSONS);
-        if (personToFavourite.getFavourite()) {
-            return new CommandResult(String.format(MESSAGE_UNFAVOURITE_PERSON_SUCCESS,
+        if (!personToFavourite.getFavourite()) {
+            return new CommandResult(String.format(MESSAGE_FAVOURITE_PERSON_SUCCESS,
                     favouritedPerson.getName().fullName));
         } else {
-            return new CommandResult(String.format(MESSAGE_FAVOURITE_PERSON_SUCCESS,
+            return new CommandResult(String.format(MESSAGE_FAVOURITE_PERSON_FAIL,
                     favouritedPerson.getName().fullName));
         }
     }
+
     /**
      * Creates and returns a {@code Person} with the details of {@code personToFavourite}
      */
     private static Person createFavouritedPerson(Person personToFavourite) {
         assert personToFavourite != null;
 
-        boolean newFavourite = !personToFavourite.getFavourite();
+        boolean newFavourite;
+
+        if (personToFavourite.getFavourite()) {
+            newFavourite = personToFavourite.getFavourite();
+        } else {
+            newFavourite = !personToFavourite.getFavourite();
+        }
 
         return new Person(personToFavourite.getName(), personToFavourite.getPhone(), personToFavourite.getEmail(),
                 personToFavourite.getAddress(), personToFavourite.getRating(), personToFavourite.getDepartment(),
                 personToFavourite.getManager(), personToFavourite.getSalary(), personToFavourite.getOtHours(),
                 personToFavourite.getOtRate(), personToFavourite.getDeductibles(), personToFavourite.getFeedback(),
                 personToFavourite.getTags(), newFavourite);
     }
+
     @Override
     public boolean equals(Object other) {
         // short circuit if same object

src/main/java/seedu/address/logic/commands/UnfavouriteCommand.java

@@ -0,0 +1,93 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.model.Model.PREDICATE_SHOW_ALL_PERSONS;
+
+import java.util.List;
+
+import seedu.address.commons.core.Messages;
+import seedu.address.commons.core.index.Index;
+import seedu.address.logic.CommandHistory;
+import seedu.address.logic.commands.exceptions.CommandException;
+import seedu.address.model.Model;
+import seedu.address.model.person.Person;
+
+/**
+ * Unfavourites an exisiting contact
+ */
+
+public class UnfavouriteCommand extends Command {
+
+    public static final String COMMAND_WORD = "unfavourite";
+    public static final String COMMAND_ALIAS = "unfav";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Removes a person from your favourite contacts "
+            + "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_UNFAVOURITE_PERSON_FAIL = "Person not in favourites: %1$s";
+    public static final String MESSAGE_UNFAVOURITE_PERSON_SUCCESS = "Person removed from favourites: %1$s";
+    public static final String MESSAGE_DUPLICATE_PERSON = "This person already exists in the address book.";
+    private final Index index;
+    /**
+     * @param index of the person in the filtered person list to edit
+     */
+    public UnfavouriteCommand(Index index) {
+        requireNonNull(index);
+        this.index = index;
+    }
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) throws CommandException {
+        List<Person> lastShownList = model.getFilteredPersonList();
+        if (index.getZeroBased() >= lastShownList.size()) {
+            throw new CommandException(Messages.MESSAGE_INVALID_PERSON_DISPLAYED_INDEX);
+        }
+        Person personToUnfavourite = lastShownList.get(index.getZeroBased());
+        Person unfavouritedPerson = createFavouritedPerson(personToUnfavourite);
+
+        model.unfavouritePerson(personToUnfavourite, unfavouritedPerson);
+
+        model.updateFilteredPersonList(PREDICATE_SHOW_ALL_PERSONS);
+        if (personToUnfavourite.getFavourite()) {
+            return new CommandResult(String.format(MESSAGE_UNFAVOURITE_PERSON_SUCCESS,
+                    unfavouritedPerson.getName().fullName));
+        } else {
+            return new CommandResult(String.format(MESSAGE_UNFAVOURITE_PERSON_FAIL,
+                    unfavouritedPerson.getName().fullName));
+        }
+    }
+    /**
+     * Creates and returns a {@code Person} with the details of {@code personToFavourite}
+     */
+    private static Person createFavouritedPerson(Person personToUnfavourite) {
+        assert personToUnfavourite != null;
+
+        boolean newFavourite;
+
+        if (personToUnfavourite.getFavourite()) {
+            newFavourite = !personToUnfavourite.getFavourite();
+        } else {
+            newFavourite = personToUnfavourite.getFavourite();
+        }
+
+        return new Person(personToUnfavourite.getName(), personToUnfavourite.getPhone(),
+                personToUnfavourite.getEmail(), personToUnfavourite.getAddress(), personToUnfavourite.getRating(),
+                personToUnfavourite.getDepartment(), personToUnfavourite.getManager(), personToUnfavourite.getSalary(),
+                personToUnfavourite.getOtHours(), personToUnfavourite.getOtRate(), personToUnfavourite.getDeductibles(),
+                personToUnfavourite.getFeedback(), personToUnfavourite.getTags(), newFavourite);
+    }
+    @Override
+    public boolean equals(Object other) {
+        // short circuit if same object
+        if (other == this) {
+            return true;
+        }
+        // instanceof handles nulls
+        if (!(other instanceof UnfavouriteCommand)) {
+            return false;
+        }
+        // state check
+        UnfavouriteCommand e = (UnfavouriteCommand) other;
+        return index.equals(e.index);
+    }
+}

src/main/java/seedu/address/logic/parser/AddressBookParser.java

@@ -23,6 +23,7 @@
 import seedu.address.logic.commands.RedoCommand;
 import seedu.address.logic.commands.SelectCommand;
 import seedu.address.logic.commands.UndoCommand;
+import seedu.address.logic.commands.UnfavouriteCommand;
 import seedu.address.logic.parser.exceptions.ParseException;
 
 /**
@@ -71,6 +72,10 @@ public Command parseCommand(String userInput) throws ParseException {
         case FavouriteCommand.COMMAND_ALIAS:
             return new FavouriteCommandParser().parse(arguments);
 
+        case UnfavouriteCommand.COMMAND_WORD:
+        case UnfavouriteCommand.COMMAND_ALIAS:
+            return new UnfavouriteCommandParser().parse(arguments);
+
         case FindCommand.COMMAND_WORD:
             return new FindCommandParser().parse(arguments);
 

src/main/java/seedu/address/logic/parser/FavouriteCommandParser.java

@@ -8,7 +8,7 @@
 import seedu.address.logic.parser.exceptions.ParseException;
 
 /**
- * Parses input arguments and creates a new DeleteCommand object
+ * Parses input arguments and creates a new FavouriteCommand object
  */
 
 public class FavouriteCommandParser implements Parser<FavouriteCommand> {

src/main/java/seedu/address/logic/parser/UnfavouriteCommandParser.java

@@ -0,0 +1,31 @@
+package seedu.address.logic.parser;
+
+import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+
+import seedu.address.commons.core.index.Index;
+import seedu.address.commons.exceptions.IllegalValueException;
+import seedu.address.logic.commands.UnfavouriteCommand;
+import seedu.address.logic.parser.exceptions.ParseException;
+
+/**
+ * Parses input arguments and creates a new FavouriteCommand object
+ */
+
+public class UnfavouriteCommandParser implements Parser<UnfavouriteCommand> {
+
+    /**
+     * Parses the given {@code String} of arguments in the context of the UnfavouriteCommand
+     * and returns an UnfavouriteCommand object for execution.
+     * @throws ParseException if the user input does not conform the expected format
+     */
+    public UnfavouriteCommand parse(String args) throws ParseException {
+        try {
+            Index index = ParserUtil.parseIndex(args);
+            return new UnfavouriteCommand(index);
+        } catch (IllegalValueException ive) {
+            throw new ParseException(
+                    String.format(MESSAGE_INVALID_COMMAND_FORMAT, UnfavouriteCommand.MESSAGE_USAGE));
+        }
+    }
+
+}

src/main/java/seedu/address/model/Model.java

@@ -48,6 +48,12 @@ public interface Model {
      */
     void favouritePerson(Person target, Person favouritedPerson);
 
+    /**
+     * Remove the given person from favourite.
+     * The person must exist in the favourites.
+     */
+    void unfavouritePerson(Person target, Person unfavouritedPerson);
+
     /** Returns an unmodifiable view of the filtered person list */
     ObservableList<Person> getFilteredPersonList();
 

src/main/java/seedu/address/model/ModelManager.java

@@ -91,6 +91,14 @@ public void favouritePerson(Person target, Person favouritedPerson) {
         indicateAddressBookChanged();
     }
 
+    @Override
+    public void unfavouritePerson(Person target, Person unfavouritedPerson) {
+        requireAllNonNull(target, unfavouritedPerson);
+
+        versionedAddressBook.favouritePerson(target, unfavouritedPerson);
+        indicateAddressBookChanged();
+    }
+
     //=========== Filtered Person List Accessors =============================================================
 
     /**

src/test/java/seedu/address/logic/commands/AddCommandTest.java

@@ -123,6 +123,11 @@ public void favouritePerson(Person target, Person favouritedPerson) {
             throw new AssertionError("This method should not be called.");
         }
 
+        @Override
+        public void unfavouritePerson(Person target, Person unfavouritedPerson) {
+            throw new AssertionError("This method should not be called.");
+        }
+
         @Override
         public ObservableList<Person> getFilteredPersonList() {
             throw new AssertionError("This method should not be called.");

src/test/java/seedu/address/logic/commands/FavouriteCommandTest.java

@@ -45,14 +45,14 @@ public void execute_validIndexUnfilteredList_success() {
 
         assertCommandSuccess(favouriteCommand, model, commandHistory, expectedFavouriteMessage, model);
 
-        // unfavourite success
+        // favourite fail
 
-        FavouriteCommand unfavouriteCommand = new FavouriteCommand(INDEX_FIRST_PERSON);
+        FavouriteCommand failFavouriteCommand = new FavouriteCommand(INDEX_FIRST_PERSON);
 
-        String expectedUnfavouriteMessage = String.format(FavouriteCommand.MESSAGE_UNFAVOURITE_PERSON_SUCCESS,
+        String expectedFailFavouriteMessage = String.format(FavouriteCommand.MESSAGE_FAVOURITE_PERSON_FAIL,
                 favouritedPerson.getName().fullName);
 
-        assertCommandSuccess(unfavouriteCommand, model, commandHistory, expectedUnfavouriteMessage, model);
+        assertCommandSuccess(failFavouriteCommand, model, commandHistory, expectedFailFavouriteMessage, model);
     }
 
     @Test