add sort function

src/main/java/seedu/address/logic/LogicManager.java

@@ -56,7 +56,7 @@ public CommandResult execute(String commandText) throws CommandException, ParseE
         }
 
         if (bookShelfModified) {
-            logger.info("Address book modified, saving to file.");
+            logger.info("Bookshelf modified, saving to file.");
             try {
                 storage.saveBookShelf(model.getBookShelf());
             } catch (IOException ioe) {

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

@@ -0,0 +1,39 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+
+import seedu.address.logic.CommandHistory;
+import seedu.address.model.Model;
+
+/**
+ * Sort all books in provided order.
+ */
+public class SortBookCommand extends Command {
+
+    public static final String COMMAND_WORD = "sortBook";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": sort all books in certain order"
+        + "the specified keywords (case-insensitive).\n"
+        + "Parameters: [st/TYPE]...[o/ORDER]...\n"
+        + "Example: " + COMMAND_WORD + " st/rating o/asc";
+
+    public static final String MESSAGE_SUCCESS = "sorted successfully";
+
+    private final String type;
+
+    private final String order;
+
+    public SortBookCommand(String type, String order) {
+        this.type = type;
+        this.order = order;
+    }
+
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) {
+        requireNonNull(model);
+
+        model.sortBook(type, order);
+        model.commitBookShelf();
+        return new CommandResult(MESSAGE_SUCCESS);
+    }
+}

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

@@ -24,6 +24,7 @@
 import seedu.address.logic.commands.ListReviewCommand;
 import seedu.address.logic.commands.RedoCommand;
 import seedu.address.logic.commands.SelectCommand;
+import seedu.address.logic.commands.SortBookCommand;
 import seedu.address.logic.commands.UndoCommand;
 import seedu.address.logic.parser.exceptions.ParseException;
 
@@ -54,59 +55,62 @@ public Command parseCommand(String userInput) throws ParseException {
         final String arguments = matcher.group("arguments");
         switch (commandWord) {
 
-        case AddCommand.COMMAND_WORD:
-            return new AddCommandParser().parse(arguments);
-
         case AddBookCommand.COMMAND_WORD:
             return new AddBookCommandParser().parse(arguments);
 
-        case EditBookCommand.COMMAND_WORD:
-            return new EditBookCommandParser().parse(arguments);
+        case AddCommand.COMMAND_WORD:
+            return new AddCommandParser().parse(arguments);
 
-        case EditCommand.COMMAND_WORD:
-            return new EditCommandParser().parse(arguments);
+        case AddReviewCommand.COMMAND_WORD:
+            return new AddReviewCommandParser().parse(arguments);
 
-        case SelectCommand.COMMAND_WORD:
-            return new SelectCommandParser().parse(arguments);
+        case ClearCommand.COMMAND_WORD:
+            return new ClearCommand();
 
         case DeleteBookCommand.COMMAND_WORD:
             return new DeleteBookCommandParser().parse(arguments);
 
-        case AddReviewCommand.COMMAND_WORD:
-            return new AddReviewCommandParser().parse(arguments);
-
         case DeleteCommand.COMMAND_WORD:
             return new DeleteCommandParser().parse(arguments);
 
-        case ClearCommand.COMMAND_WORD:
-            return new ClearCommand();
+        case EditBookCommand.COMMAND_WORD:
+            return new EditBookCommandParser().parse(arguments);
+
+        case EditCommand.COMMAND_WORD:
+            return new EditCommandParser().parse(arguments);
+
+        case ExitCommand.COMMAND_WORD:
+            return new ExitCommand();
 
         case FindCommand.COMMAND_WORD:
             return new FindCommandParser().parse(arguments);
 
-        case ListCommand.COMMAND_WORD:
-            return new ListCommand();
+        case HelpCommand.COMMAND_WORD:
+            return new HelpCommand();
+
+        case HistoryCommand.COMMAND_WORD:
+            return new HistoryCommand();
+
+        case RedoCommand.COMMAND_WORD:
+            return new RedoCommand();
 
         case ListBookCommand.COMMAND_WORD:
             return new ListBookCommandParser().parse(arguments);
 
+        case ListCommand.COMMAND_WORD:
+            return new ListCommand();
+
         case ListReviewCommand.COMMAND_WORD:
             return new ListReviewCommandParser().parse(arguments);
 
-        case HistoryCommand.COMMAND_WORD:
-            return new HistoryCommand();
-
-        case ExitCommand.COMMAND_WORD:
-            return new ExitCommand();
-
-        case HelpCommand.COMMAND_WORD:
-            return new HelpCommand();
-
         case UndoCommand.COMMAND_WORD:
             return new UndoCommand();
 
-        case RedoCommand.COMMAND_WORD:
-            return new RedoCommand();
+        case SelectCommand.COMMAND_WORD:
+            return new SelectCommandParser().parse(arguments);
+
+        case SortBookCommand.COMMAND_WORD:
+            return new SortBookCommandParser().parse(arguments);
 
         default:
             throw new ParseException(MESSAGE_UNKNOWN_COMMAND);

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

@@ -15,4 +15,6 @@ public class CliSyntax {
     public static final Prefix PREFIX_TAG = new Prefix("t/");
     public static final Prefix PREFIX_REVIEW = new Prefix("r/");
     public static final Prefix PREFIX_REVIEWTITLE = new Prefix("rt/");
+    public static final Prefix PREFIX_SORTTYPE = new Prefix("st/");
+    public static final Prefix PREFIX_ORDER = new Prefix("o/");
 }

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

@@ -0,0 +1,46 @@
+package seedu.address.logic.parser;
+
+import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_ORDER;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_SORTTYPE;
+
+import java.util.stream.Stream;
+
+import seedu.address.logic.commands.SortBookCommand;
+import seedu.address.logic.parser.exceptions.ParseException;
+
+
+/**
+ * Parses input arguments and creates a new SortBookCommand object
+ */
+public class SortBookCommandParser implements Parser<SortBookCommand> {
+    /**
+     * Parses the given {@code String} of arguments in the context of the SortBookCommand
+     * and returns an SortBookCommand object for execution.
+     * @throws ParseException if the user input does not conform the expected format
+     */
+    public SortBookCommand parse(String args) throws ParseException {
+        ArgumentMultimap argMultimap =
+            ArgumentTokenizer.tokenize(args, PREFIX_SORTTYPE, PREFIX_ORDER);
+
+        if (!arePrefixesPresent(argMultimap, PREFIX_SORTTYPE, PREFIX_ORDER)
+            || !argMultimap.getPreamble().isEmpty()
+            && (!argMultimap.getValue(PREFIX_ORDER).get().toUpperCase().equals("ASC")
+            || !argMultimap.getValue(PREFIX_ORDER).get().toUpperCase().equals("DES"))) {
+            throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, SortBookCommand.MESSAGE_USAGE));
+        }
+
+        String sortType = argMultimap.getValue(PREFIX_SORTTYPE).get();
+        String orderType = argMultimap.getValue(PREFIX_ORDER).get();
+
+        return new SortBookCommand(sortType, orderType);
+    }
+
+    /**
+     * Returns true if none of the prefixes contains empty {@code Optional} values in the given
+     * {@code ArgumentMultimap}.
+     */
+    private static boolean arePrefixesPresent(ArgumentMultimap argumentMultimap, Prefix... prefixes) {
+        return Stream.of(prefixes).allMatch(prefix -> argumentMultimap.getValue(prefix).isPresent());
+    }
+}

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

@@ -25,6 +25,7 @@ public class BookShelf implements ReadOnlyBookShelf {
     private final UniqueBookList books;
     private final InvalidationListenerManager invalidationListenerManager = new InvalidationListenerManager();
 
+
     /*
      * The 'unusual' code block below is an non-static initialization block, sometimes used to avoid duplication
      * between constructors. See https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html
@@ -190,6 +191,22 @@ public void removeTag(Tag tag) {
         }
     }
 
+    /**
+     * Sort {@code books} in with {@code order}
+     * @param type
+     * @param order
+     * @throws Exception
+     */
+
+    public void sort(String type, String order) {
+        try {
+            books.sortBooks(type, order);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        indicateModified();
+    }
+
     @Override
     public void addListener(InvalidationListener listener) {
         invalidationListenerManager.addListener(listener);

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

@@ -185,4 +185,9 @@ public interface Model {
      * Delete the tag{@code tag} of all contacts in the phone book
      */
     void deleteTag(Tag tag);
+
+    /**
+     * Sort the Book list into different order
+     */
+    void sortBook(String type, String order);
 }

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

@@ -152,6 +152,12 @@ public void deleteTag(Tag tag) {
         versionedBookShelf.removeTag(tag);
     }
 
+    @Override
+    public void sortBook(String type, String order) {
+        versionedBookShelf.sort(type, order);
+    }
+
+
     //=========== Filtered Person List Accessors =============================================================
 
     /**

src/main/java/seedu/address/model/book/Book.java

@@ -10,7 +10,7 @@
 import seedu.address.model.tag.Tag;
 
 /**
- * Represents a Book in the address book.
+ * Represents a Book in the bookShelf.
  * Guarantees: details are present and not null, field values are validated, immutable.
  */
 public class Book {

src/main/java/seedu/address/model/book/UniqueBookList.java

@@ -3,6 +3,7 @@
 import static java.util.Objects.requireNonNull;
 import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
 
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 
@@ -25,7 +26,7 @@
  */
 public class UniqueBookList implements Iterable<Book> {
 
-    private final ObservableList<Book> internalList = FXCollections.observableArrayList();
+    private ObservableList<Book> internalList = FXCollections.observableArrayList();
     private final ObservableList<Book> internalUnmodifiableList =
             FXCollections.unmodifiableObservableList(internalList);
 
@@ -98,6 +99,48 @@ public void setBooks(List<Book> books) {
         internalList.setAll(books);
     }
 
+    /**
+     * Sort the books with {@code type} in {@code order}.
+     * @param type sorting type
+     * @param order order of sorting
+     */
+    public void sortBooks(String type, String order) throws Exception {
+        requireAllNonNull(type, order);
+        type = type.toUpperCase();
+        order = order.toUpperCase();
+
+        switch (type) {
+        case "AUTHOR":
+            if (order.equals("ASC")) {
+                internalList.sort(Comparator.comparing(a -> a.getAuthor().toString().toLowerCase()));
+            } else if (order.equals("DES")) {
+                internalList.sort((a, b)
+                    -> b.getAuthor().toString().toLowerCase().compareTo(a.getAuthor().toString().toLowerCase()));
+            }
+            break;
+
+        case "NAME":
+            if (order.equals("ASC")) {
+                internalList.sort(Comparator.comparing(a -> a.getBookName().toString().toLowerCase()));
+            } else if (order.equals("DES")) {
+                internalList.sort((a, b)
+                    -> b.getBookName().toString().toLowerCase().compareTo(a.getBookName().toString().toLowerCase()));
+            }
+            break;
+
+        case "RATING":
+            if (order.equals("ASC")) {
+                FXCollections.sort(internalList, Comparator.comparingInt(a -> Integer.valueOf(a.getRating().value)));
+            } else if (order.equals("DES")) {
+                FXCollections.sort(internalList, (a, b)
+                    -> Integer.valueOf(b.getRating().value) - Integer.valueOf(a.getRating().value));
+            }
+            break;
+        default:
+            throw new Exception("Unknown sorting type");
+        }
+    }
+
     /**
      * Returns the backing list as an unmodifiable {@code ObservableList}.
      */

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

@@ -251,6 +251,11 @@ public void setSelectedBook(Book book) {
         public void deleteTag(Tag tag) {
             throw new AssertionError("This method should not be called.");
         }
+
+        @Override
+        public void sortBook(String type, String order) {
+            throw new AssertionError("This method should not be called.");
+        }
     }
 
     /**

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

@@ -250,6 +250,11 @@ public void setSelectedBook(Book book) {
         public void deleteTag(Tag tag) {
             throw new AssertionError("This method should not be called.");
         }
+
+        @Override
+        public void sortBook(String type, String order) {
+            throw new AssertionError("This method should not be called.");
+        }
     }
 
     /**