Persistent search

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

@@ -37,6 +37,7 @@
 
     private final EventManager eventManager;
 
+
     /**
      * Constructs a {@code LogicManager} with the given {@code Model} and {@code Storage}.
      */
@@ -52,7 +53,15 @@
         logger.info("----------------[USER COMMAND][" + commandText + "]");
 
         CommandResult commandResult;
-        Command contactCommand = addressBookParser.parseCommand(commandText);
+        Command contactCommand;
+        if (model.getSearchMode()) {
+            logger.info("Searchmode command detected");
+            contactCommand = addressBookParser.parseSearchCommand(commandText);
+
+        } else {
+            contactCommand = addressBookParser.parseCommand(commandText);
+
+        }
         commandResult = contactCommand.execute(model, eventManager);
 
         try {

src/main/java/seedu/address/logic/commands/contact/commands/FindCommand.java

@@ -8,7 +8,7 @@
 import seedu.address.logic.commands.CommandResult;
 import seedu.address.model.Model;
 import seedu.address.model.event.EventManager;
-import seedu.address.model.person.NameContainsKeywordsPredicate;
+import seedu.address.model.person.predicates.NameContainsKeywordsPredicate;
 
 /**
  * Finds and lists all persons in address book whose name contains any of the argument keywords.

src/main/java/seedu/address/logic/commands/contact/commands/SearchCommand.java

@@ -8,7 +8,7 @@
 import seedu.address.logic.commands.CommandResult;
 import seedu.address.model.Model;
 import seedu.address.model.event.EventManager;
-import seedu.address.model.person.PersonIsRolePredicate;
+import seedu.address.model.person.predicates.PersonIsRolePredicate;
 
 /**
  * Finds and lists all persons in address book who has any role equal to any of the role keywords.

src/main/java/seedu/address/logic/commands/searchmode/ExitSearchModeCommand.java

@@ -0,0 +1,38 @@
+package seedu.address.logic.commands.searchmode;
+
+import static java.util.Objects.requireNonNull;
+
+import seedu.address.logic.commands.Command;
+import seedu.address.logic.commands.CommandResult;
+import seedu.address.model.Model;
+import seedu.address.model.event.EventManager;
+
+
+/**
+ * Exits search mode.
+ */
+public class ExitSearchModeCommand extends Command {
+    public static final String COMMAND_WORD = "exitsearchmode";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Exits search mode.\n"
+            + "Example: " + COMMAND_WORD;
+
+    public static final String MESSAGE_SUCCESS = "Exited search mode.";
+
+    public ExitSearchModeCommand() {
+    }
+    @Override
+    public CommandResult execute(Model model, EventManager eventManager) {
+        requireNonNull(model);
+        model.setSearchMode(false);
+        model.updateFilteredPersonList(Model.PREDICATE_SHOW_ALL_PERSONS);
+        return new CommandResult(MESSAGE_SUCCESS);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || other instanceof ExitSearchModeCommand; // instanceof handles nulls
+    }
+
+}

src/main/java/seedu/address/logic/commands/searchmode/InitSearchModeCommand.java

@@ -0,0 +1,33 @@
+package seedu.address.logic.commands.searchmode;
+
+import static java.util.Objects.requireNonNull;
+
+import seedu.address.logic.commands.Command;
+import seedu.address.logic.commands.CommandResult;
+import seedu.address.model.Model;
+import seedu.address.model.event.EventManager;
+
+
+/**
+ * Enters search mode.
+ */
+public class InitSearchModeCommand extends Command {
+    public static final String COMMAND_WORD = "searchmode";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Enters search mode.\n"
+            + "Example: " + COMMAND_WORD;
+
+    public static final String MESSAGE_SUCCESS = "Entered search mode.";
+
+    public InitSearchModeCommand() {
+    }
+    @Override
+    public CommandResult execute(Model model, EventManager eventManager) {
+        requireNonNull(model);
+        model.setSearchMode(true);
+        // empties the current displayed list
+        model.updateFilteredPersonList(person -> false);
+        return new CommandResult(MESSAGE_SUCCESS);
+    }
+
+}

src/main/java/seedu/address/logic/commands/searchmode/SearchModeSearchCommand.java

@@ -0,0 +1,59 @@
+package seedu.address.logic.commands.searchmode;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import seedu.address.logic.commands.Command;
+import seedu.address.logic.commands.CommandResult;
+import seedu.address.model.Model;
+import seedu.address.model.event.EventManager;
+import seedu.address.model.person.Person;
+
+
+/**
+ * Searches for all persons in the address book whose names contain all the specified keywords.
+ */
+public class SearchModeSearchCommand extends Command {
+    public static final String COMMAND_WORD = "search";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD
+            + ": Searches for all persons whose fields contain the specified keywords (case-insensitive) "
+            + "and displays them as a list with index numbers.\n"
+            + "Parameters: [Flag] [MORE_KEYWORDS]...\n"
+            + "Example: " + COMMAND_WORD + " n/Amy Bob Charlie";
+
+    public static final String MESSAGE_SUCCESS = "Added all Persons who fit search parameter";
+
+    //maintains a set of predicates, reducing them to get the final predicate in execute
+    private final Set<Predicate<Person>> predicates = new HashSet<>();
+
+    public SearchModeSearchCommand(Predicate<Person> predicate) {
+        this.predicates.add(predicate);
+    }
+
+    public SearchModeSearchCommand(Set<Predicate<Person>> predicates) {
+        this.predicates.addAll(predicates);
+    }
+
+    @Override
+    public CommandResult execute(Model model, EventManager eventManager) {
+        // combine the new predicates with the old ones
+        Predicate<Person> currPredicate = model.getLastPredicate();
+        Predicate<Person> predicate = predicates.stream().reduce(Predicate::and).orElse(x -> true);
+        Predicate<Person> newPredicate = currPredicate.or(predicate);
+        model.updateFilteredPersonList(newPredicate);
+        return new CommandResult(MESSAGE_SUCCESS);
+    }
+
+    public Set<Predicate<Person>> getPredicates() {
+        return predicates;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof SearchModeSearchCommand // instanceof handles nulls
+                && predicates.equals(((SearchModeSearchCommand) other).predicates));
+    }
+}

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

@@ -22,6 +22,9 @@
 import seedu.address.logic.commands.event.commands.AddPersonToEventCommand;
 import seedu.address.logic.commands.event.commands.RemovePersonFromEventCommand;
 import seedu.address.logic.commands.event.commands.ViewEventCommand;
+import seedu.address.logic.commands.searchmode.ExitSearchModeCommand;
+import seedu.address.logic.commands.searchmode.InitSearchModeCommand;
+import seedu.address.logic.commands.searchmode.SearchModeSearchCommand;
 import seedu.address.logic.parser.contact.parser.AddCommandParser;
 import seedu.address.logic.parser.contact.parser.DeleteCommandParser;
 import seedu.address.logic.parser.contact.parser.EditCommandParser;
@@ -97,6 +100,9 @@
         case AddEventCommand.COMMAND_WORD:
             return new NewEventCommandParser().parse(arguments);
 
+        case InitSearchModeCommand.COMMAND_WORD:
+            return new InitSearchModeCommand();
+
         case ViewEventCommand.COMMAND_WORD:
             return new ViewEventCommandParser().parse(arguments);
 
@@ -112,4 +118,36 @@
         }
     }
 
+    /**
+     * Parses user input into command for execution in search mode.
+     *
+     * @param userInput full user input string
+     * @return the command based on the user input
+     * @throws ParseException if the user input does not conform the expected format
+     */
+    public Command parseSearchCommand(String userInput) throws ParseException {
+        final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(userInput.trim());
+        if (!matcher.matches()) {
+            logger.warning("This user input caused a ParseException: " + userInput);
+            throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
+        }
+
+        final String commandWord = matcher.group("commandWord");
+        final String arguments = matcher.group("arguments");
+
+        // Note to developers: Change the log level in config.json to enable lower level (i.e., FINE, FINER and lower)
+        // log messages such as the one below.
+        // Lower level log messages are used sparingly to minimize noise in the code.
+        logger.fine("Using SearchCommandParser to parse user input: " + userInput);
+        logger.fine("Command word: " + commandWord + "; Arguments: " + arguments);
+        switch (commandWord) {
+        case ExitSearchModeCommand.COMMAND_WORD:
+            return new ExitSearchModeCommand();
+        case SearchModeSearchCommand.COMMAND_WORD:
+            return new SearchModeSearchCommandParser().parse(arguments);
+        default:
+            throw new ParseException(MESSAGE_UNKNOWN_COMMAND);
+        }
+    }
+
 }

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

@@ -0,0 +1,141 @@
+package seedu.address.logic.parser;
+
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_ADDRESS;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_EMAIL;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_PHONE;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_ROLE;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_TELEGRAM;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import seedu.address.logic.Messages;
+import seedu.address.logic.commands.searchmode.SearchModeSearchCommand;
+import seedu.address.logic.parser.exceptions.ParseException;
+import seedu.address.model.person.Person;
+import seedu.address.model.person.predicates.AddressContainsKeywordsPredicate;
+import seedu.address.model.person.predicates.EmailContainsKeywordsPredicate;
+import seedu.address.model.person.predicates.NameContainsKeywordsPredicate;
+import seedu.address.model.person.predicates.PersonIsRolePredicate;
+import seedu.address.model.person.predicates.PhoneNumberContainsKeywordPredicate;
+import seedu.address.model.person.predicates.TelegramContainsKeywordsPredicate;
+import seedu.address.model.role.Role;
+
+/**
+ * Parses input arguments and creates a new SearchModeSearchCommand object
+ */
+public class SearchModeSearchCommandParser implements Parser<SearchModeSearchCommand> {
+    private static final Logger logger = Logger.getLogger(SearchModeSearchCommandParser.class.getName());
+    @Override
+    public SearchModeSearchCommand parse(String args) throws ParseException {
+        requireNonNull(args);
+        ArgumentMultimap argMultimap =
+                ArgumentTokenizer.tokenize(args, PREFIX_NAME, PREFIX_PHONE, PREFIX_EMAIL, PREFIX_ADDRESS,
+                        PREFIX_TELEGRAM, PREFIX_ROLE);
+        argMultimap.verifyNoDuplicatePrefixesFor(PREFIX_NAME, PREFIX_PHONE, PREFIX_EMAIL, PREFIX_ADDRESS,
+                PREFIX_TELEGRAM, PREFIX_ROLE);
+        //for each prefix, if present, parse the value and create a predicate...
+        // combine the predicates using AND
+        // return the search command with the predicate
+        // original predicate just show all
+        Set<Predicate<Person>> predicates = new HashSet<>();
+        // if a field is present, AND with the predicate for that field
+        if (argMultimap.getValue(PREFIX_NAME).isPresent()) {
+            Predicate<Person> namePred = createPersonPredicate(argMultimap);
+            predicates.add(namePred);
+        }
+        if (argMultimap.getValue(PREFIX_PHONE).isPresent()) {
+            Predicate<Person> phonePred = createPhonePredicate(argMultimap);
+            predicates.add(phonePred);
+        }
+        if (argMultimap.getValue(PREFIX_EMAIL).isPresent()) {
+            Predicate<Person> emailPred = createEmailPredicate(argMultimap);
+            predicates.add(emailPred);
+        }
+        if (argMultimap.getValue(PREFIX_ADDRESS).isPresent()) {
+            Predicate<Person> addressPred = createAddressPredicate(argMultimap);
+
+            predicates.add(addressPred);
+        }
+        if (argMultimap.getValue(PREFIX_TELEGRAM).isPresent()) {
+            Predicate<Person> telegramPred = createTelegramPredicate(argMultimap);
+            predicates.add(telegramPred);
+        }
+        //role have to use separate predicate
+        if (argMultimap.getValue(PREFIX_ROLE).isPresent()) {
+            Predicate<Person> rolePred = createRolePredicate(argMultimap);
+            predicates.add(rolePred);
+        }
+        if (predicates.isEmpty()) {
+            throw new ParseException(String.format(Messages.MESSAGE_INVALID_COMMAND_FORMAT,
+                    SearchModeSearchCommand.MESSAGE_USAGE));
+        }
+        return new SearchModeSearchCommand(predicates);
+    }
+
+    private static Predicate<Person> createRolePredicate(ArgumentMultimap argMultimap) throws ParseException {
+        String roles = argMultimap.getValue(PREFIX_ROLE).get().trim();
+        // map each word in String roles to a Role object
+
+
+        Set<Role> roleSet = ParserUtil.parseRoles(argMultimap.getAllValues(PREFIX_ROLE));
+        List<Role> roleList = roleSet.stream().collect(Collectors.toList());
+
+        Predicate<Person> rolePred = new PersonIsRolePredicate(roleList);
+        return rolePred;
+    }
+
+    private static Predicate<Person> createTelegramPredicate(ArgumentMultimap argMultimap) {
+        String telegram = argMultimap.getValue(PREFIX_TELEGRAM).get().trim();
+        String[] telegramKeywords = telegram.split("\\s+");
+        Predicate<Person> telegramPred = new TelegramContainsKeywordsPredicate(
+                Arrays.stream(telegramKeywords).toList());
+        return telegramPred;
+    }
+
+    private static Predicate<Person> createAddressPredicate(ArgumentMultimap argMultimap) {
+        String address = argMultimap.getValue(PREFIX_ADDRESS).get().trim();
+        String[] addressKeywords = address.split("\\s+");
+        Predicate<Person> addressPred = new AddressContainsKeywordsPredicate(
+                Arrays.stream(addressKeywords).toList());
+        return addressPred;
+    }
+
+    private static Predicate<Person> createEmailPredicate(ArgumentMultimap argMultimap) {
+        String email = argMultimap.getValue(PREFIX_EMAIL).get().trim();
+        String[] emailKeywords = email.split("\\s+");
+
+        Predicate<Person> emailPred = new EmailContainsKeywordsPredicate(
+                Arrays.stream(emailKeywords).toList());
+        return emailPred;
+    }
+
+    private static Predicate<Person> createPhonePredicate(ArgumentMultimap argMultimap) {
+        String phone = argMultimap.getValue(PREFIX_PHONE).get().trim();
+        String[] phoneKeywords = phone.split("\\s+");
+
+        Predicate<Person> phonePred = new PhoneNumberContainsKeywordPredicate(
+                Arrays.stream(phoneKeywords).toList());
+        return phonePred;
+    }
+
+    private static Predicate<Person> createPersonPredicate(ArgumentMultimap argMultimap) {
+        String name = argMultimap.getValue(PREFIX_NAME).get().trim();
+
+        String[] nameKeywords = name.split("\\s+");
+
+        Predicate<Person> namePred = new NameContainsKeywordsPredicate(
+                Arrays.stream(nameKeywords).toList());
+        return namePred;
+    }
+
+
+}

src/main/java/seedu/address/logic/parser/contact/parser/FindCommandParser.java

@@ -7,7 +7,7 @@
 import seedu.address.logic.commands.contact.commands.FindCommand;
 import seedu.address.logic.parser.Parser;
 import seedu.address.logic.parser.exceptions.ParseException;
-import seedu.address.model.person.NameContainsKeywordsPredicate;
+import seedu.address.model.person.predicates.NameContainsKeywordsPredicate;
 
 /**
  * Parses input arguments and creates a new FindCommand object

src/main/java/seedu/address/logic/parser/contact/parser/SearchCommandParser.java

@@ -10,7 +10,7 @@
 import seedu.address.logic.commands.contact.commands.SearchCommand;
 import seedu.address.logic.parser.Parser;
 import seedu.address.logic.parser.exceptions.ParseException;
-import seedu.address.model.person.PersonIsRolePredicate;
+import seedu.address.model.person.predicates.PersonIsRolePredicate;
 import seedu.address.model.role.Role;