[CS2103-T17-1] TeamBuilder

src/main/java/teambuilder/commons/core/Messages.java

@@ -10,7 +10,7 @@ public class Messages {
     public static final String MESSAGE_INVALID_PERSON_DISPLAYED_INDEX = "The person index provided is invalid";
     public static final String MESSAGE_PERSONS_LISTED_OVERVIEW = "%1$d persons listed!";
     public static final String MESSAGE_INVALID_SORTING_ORDER = "Invalid sorting order, input \"desc\" or \"asc\"";
-
+    public static final String MESSAGE_INVALID_TEAM = "The team name provided is invalid";
     public static final String MESSAGE_INVALID_SORT_BY = "Invalid sort by";
 
 }

src/main/java/teambuilder/logic/commands/AddCommand.java

@@ -8,11 +8,15 @@
 import static teambuilder.logic.parser.CliSyntax.PREFIX_PHONE;
 import static teambuilder.logic.parser.CliSyntax.PREFIX_TAG;
 
+import java.util.List;
+
 import teambuilder.commons.core.Memento;
 import teambuilder.commons.util.HistoryUtil;
 import teambuilder.logic.commands.exceptions.CommandException;
 import teambuilder.model.Model;
 import teambuilder.model.person.Person;
+import teambuilder.model.tag.Tag;
+import teambuilder.model.team.Team;
 
 /**
  * Adds a person to the address book.
@@ -41,6 +45,7 @@ public class AddCommand extends Command {
 
     public static final String MESSAGE_SUCCESS = "New person added: %1$s";
     public static final String MESSAGE_DUPLICATE_PERSON = "This person already exists in the address book";
+    public static final String MESSAGE_TEAM_NOT_FOUND = "The team does not exist in the address book";
 
     private final Person toAdd;
 
@@ -60,10 +65,28 @@ public CommandResult execute(Model model) throws CommandException {
             throw new CommandException(MESSAGE_DUPLICATE_PERSON);
         }
 
+        // throw exception if team tags not from existing teams
+        List<Team> teamList = model.getTeamList();
+        Object[] teamTags = toAdd.getTeams().toArray();
+        for (Object tag : teamTags) {
+            Tag castedTag = (Tag) tag;
+            boolean isPresent = false;
+            for (Team team : teamList) {
+                if (castedTag.getName().equals(team.toString())) {
+                    isPresent = true;
+                    break;
+                }
+            }
+            if (!isPresent) {
+                throw new CommandException(MESSAGE_TEAM_NOT_FOUND);
+            }
+        }
+
         Memento old = model.save();
         HistoryUtil.getInstance().storePast(old, COMMAND_WORD + " " + toAdd);
 
         model.addPerson(toAdd);
+        model.updatePersonInTeams(toAdd);
         return new CommandResult(String.format(MESSAGE_SUCCESS, toAdd));
     }
 

src/main/java/teambuilder/logic/commands/CreateCommand.java

@@ -46,11 +46,11 @@ public CreateCommand(Team team) {
     public CommandResult execute(Model model) throws CommandException {
         requireNonNull(model);
 
-        //        if (model.hasTeam(toCreate)) {
-        //            throw new CommandException(MESSAGE_DUPLICATE_TEAM);
-        //        }
-        //
-        //        model.addTeam(toCreate);
+        if (model.hasTeam(toCreate)) {
+            throw new CommandException(MESSAGE_DUPLICATE_TEAM);
+        }
+
+        model.addTeam(toCreate);
 
         return new CommandResult(String.format(MESSAGE_SUCCESS, toCreate));
     }

src/main/java/teambuilder/logic/commands/DeleteCommand.java

@@ -45,6 +45,7 @@ public CommandResult execute(Model model) throws CommandException {
         Memento old = model.save();
         HistoryUtil.getInstance().storePast(old, COMMAND_WORD + " " + personToDelete);
 
+        model.removeFromAllTeams(personToDelete);
         model.deletePerson(personToDelete);
         return new CommandResult(String.format(MESSAGE_DELETE_PERSON_SUCCESS, personToDelete));
     }

src/main/java/teambuilder/logic/commands/EditCommand.java

@@ -30,6 +30,7 @@
 import teambuilder.model.person.Person;
 import teambuilder.model.person.Phone;
 import teambuilder.model.tag.Tag;
+import teambuilder.model.team.Team;
 
 /**
  * Edits the details of an existing person in the address book.
@@ -58,6 +59,7 @@ public class EditCommand extends Command {
     public static final String MESSAGE_EDIT_PERSON_SUCCESS = "Edited Person: %1$s";
     public static final String MESSAGE_NOT_EDITED = "At least one field to edit must be provided.";
     public static final String MESSAGE_DUPLICATE_PERSON = "This person already exists in the address book.";
+    public static final String MESSAGE_TEAM_NOT_FOUND = "The team does not exist in the address book";
 
     private final Index index;
     private final EditPersonDescriptor editPersonDescriptor;
@@ -90,10 +92,28 @@ public CommandResult execute(Model model) throws CommandException {
             throw new CommandException(MESSAGE_DUPLICATE_PERSON);
         }
 
+        // throw exception if team tags not from existing teams
+        List<Team> teamList = model.getTeamList();
+        Object[] teamTags = editedPerson.getTeams().toArray();
+        for (Object tag : teamTags) {
+            Tag castedTag = (Tag) tag;
+            boolean isPresent = false;
+            for (Team team : teamList) {
+                if (castedTag.getName().equals(team.toString())) {
+                    isPresent = true;
+                    break;
+                }
+            }
+            if (!isPresent) {
+                throw new CommandException(MESSAGE_TEAM_NOT_FOUND);
+            }
+        }
+
         Memento old = model.save();
         HistoryUtil.getInstance().storePast(old, COMMAND_WORD + " " + editedPerson);
 
         model.setPerson(personToEdit, editedPerson);
+        model.updatePersonInTeams(editedPerson);
         model.updateFilteredPersonList(PREDICATE_SHOW_ALL_PERSONS);
         return new CommandResult(String.format(MESSAGE_EDIT_PERSON_SUCCESS, editedPerson));
     }

src/main/java/teambuilder/logic/commands/RemoveCommand.java

@@ -0,0 +1,63 @@
+package teambuilder.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+
+import teambuilder.commons.core.Memento;
+import teambuilder.commons.core.Messages;
+import teambuilder.commons.util.HistoryUtil;
+import teambuilder.logic.commands.exceptions.CommandException;
+import teambuilder.model.Model;
+import teambuilder.model.team.Team;
+import teambuilder.model.team.TeamName;
+
+/**
+ * Removes a team identified using its name from the address book.
+ */
+public class RemoveCommand extends Command {
+    public static final String COMMAND_WORD = "remove";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD
+            + ": Removes the team identified by its name.\n"
+            + "Parameters: TEAMNAME \n" + "Example: " + COMMAND_WORD + " Team A";
+
+    public static final String MESSAGE_DELETE_TEAM_SUCCESS = "Removed Team: %1$s";
+
+    private final TeamName targetName;
+
+    public RemoveCommand(TeamName targetName) {
+        this.targetName = targetName;
+    }
+
+    @Override
+    public CommandResult execute(Model model) throws CommandException {
+        requireNonNull(model);
+        List<Team> lastShownList = model.getTeamList();
+        Team teamToDelete = null;
+
+        for (Team team : lastShownList) {
+            if (team.getName().equals(targetName)) {
+                teamToDelete = team;
+                break;
+            }
+        }
+
+        if (teamToDelete == null) {
+            throw new CommandException(Messages.MESSAGE_INVALID_TEAM);
+        }
+
+        Memento old = model.save();
+        HistoryUtil.getInstance().storePast(old, COMMAND_WORD + " " + teamToDelete);
+
+        model.deleteTeam(teamToDelete);
+        return new CommandResult(String.format(MESSAGE_DELETE_TEAM_SUCCESS, teamToDelete));
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof RemoveCommand // instanceof handles nulls
+                && targetName.equals(((RemoveCommand) other).targetName)); // state check
+    }
+}

src/main/java/teambuilder/logic/parser/RemoveCommandParser.java

@@ -0,0 +1,28 @@
+package teambuilder.logic.parser;
+
+import static teambuilder.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+
+import teambuilder.logic.commands.RemoveCommand;
+import teambuilder.logic.parser.exceptions.ParseException;
+import teambuilder.model.team.TeamName;
+
+/**
+ * Parses input arguments and creates a new RemoveCommand object
+ */
+public class RemoveCommandParser {
+    /**
+     * Parses the given {@code String} of arguments in the context of the RemoveCommand
+     * and returns a RemoveCommand object for execution.
+     * @throws ParseException if the user input does not conform the expected format
+     */
+    public RemoveCommand parse(String args) throws ParseException {
+        try {
+            TeamName name = ParserUtil.parseTeamName(args);
+            return new RemoveCommand(name);
+        } catch (ParseException pe) {
+            throw new ParseException(
+                    String.format(MESSAGE_INVALID_COMMAND_FORMAT, RemoveCommand.MESSAGE_USAGE), pe);
+        }
+    }
+
+}

src/main/java/teambuilder/logic/parser/TeamBuilderParser.java

@@ -17,6 +17,7 @@
 import teambuilder.logic.commands.HelpCommand;
 import teambuilder.logic.commands.ListCommand;
 import teambuilder.logic.commands.RedoCommand;
+import teambuilder.logic.commands.RemoveCommand;
 import teambuilder.logic.commands.SortCommand;
 import teambuilder.logic.commands.UndoCommand;
 import teambuilder.logic.parser.exceptions.ParseException;
@@ -83,6 +84,9 @@ public Command parseCommand(String userInput) throws ParseException {
         case CreateCommand.COMMAND_WORD:
             return new CreateCommandParser().parse(arguments);
 
+        case RemoveCommand.COMMAND_WORD:
+            return new RemoveCommandParser().parse(arguments);
+
         default:
             throw new ParseException(MESSAGE_UNKNOWN_COMMAND);
         }

src/main/java/teambuilder/model/Model.java

@@ -8,6 +8,7 @@
 import teambuilder.commons.core.GuiSettings;
 import teambuilder.commons.core.Originator;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 
 /**
  * The API of the Model component.
@@ -78,9 +79,39 @@ public interface Model extends Originator {
      */
     void setPerson(Person target, Person editedPerson);
 
+    /**
+     * Returns true if a team with the same identity as {@code team} exists in the address book.
+     */
+    boolean hasTeam(Team team);
+
+    /**
+     * Deletes the given team.
+     * The team must exist in the address book.
+     */
+    void deleteTeam(Team target);
+
+    /**
+     * Adds the given team.
+     * {@code team} must not already exist in the address book.
+     */
+    void addTeam(Team team);
+
+    /**
+     * Adds person to the team, based on its team tags.
+     */
+    void updatePersonInTeams(Person person);
+
+    /**
+     * Removes person from all teams
+     */
+    void removeFromAllTeams(Person person);
+
     /** Returns an unmodifiable view of the filtered person list */
     ObservableList<Person> getSortedPersonList();
 
+    /** Returns an unmodifiable view of the team list */
+    ObservableList<Team> getTeamList();
+
     /**
      * Updates the filter of the filtered person list to filter by the given {@code predicate}.
      * @throws NullPointerException if {@code predicate} is null.

src/main/java/teambuilder/model/ModelManager.java

@@ -15,6 +15,7 @@
 import teambuilder.commons.core.LogsCenter;
 import teambuilder.commons.core.Memento;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 
 /**
  * Represents the in-memory model of the address book data.
@@ -26,6 +27,7 @@ public class ModelManager implements Model {
     private final UserPrefs userPrefs;
     private final FilteredList<Person> filteredPersons;
     private final SortedList<Person> sortedPersons;
+    private final FilteredList<Team> filteredTeams;
 
     /**
      * Initializes a ModelManager with the given addressBook and userPrefs.
@@ -39,6 +41,7 @@ public ModelManager(ReadOnlyTeamBuilder addressBook, ReadOnlyUserPrefs userPrefs
         this.userPrefs = new UserPrefs(userPrefs);
         filteredPersons = new FilteredList<>(this.addressBook.getPersonList());
         sortedPersons = new SortedList<>(filteredPersons);
+        filteredTeams = new FilteredList<>(this.addressBook.getTeamList());
     }
 
     public ModelManager() {
@@ -121,6 +124,44 @@ public void setPerson(Person target, Person editedPerson) {
         addressBook.setPerson(target, editedPerson);
     }
 
+    @Override
+    public boolean hasTeam(Team team) {
+        requireNonNull(team);
+        return addressBook.hasTeam(team);
+    }
+
+    @Override
+    public void addTeam(Team team) {
+        addressBook.addTeam(team);
+        //updateFilteredPersonList(PREDICATE_SHOW_ALL_PERSONS);
+    }
+
+    @Override
+    public void deleteTeam(Team target) {
+        addressBook.removeTeam(target);
+    }
+
+    @Override
+    public void updatePersonInTeams(Person person) {
+        addressBook.updatePersonInTeams(person);
+    }
+
+    @Override
+    public void removeFromAllTeams(Person person) {
+        addressBook.removeFromAllTeams(person);
+    }
+
+    //=========== Filtered Team List Accessors ===============================================================
+
+    /**
+     * Returns an unmodifiable view of the list of {@code Team} backed by the internal list of
+     * {@code versionedAddressBook}
+     */
+    @Override
+    public ObservableList<Team> getTeamList() {
+        return filteredTeams;
+    }
+
     //=========== Filtered Person List Accessors =============================================================
 
     /**

src/main/java/teambuilder/model/ReadOnlyTeamBuilder.java

@@ -2,6 +2,7 @@
 
 import javafx.collections.ObservableList;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 
 /**
  * Unmodifiable view of an address book
@@ -14,4 +15,10 @@ public interface ReadOnlyTeamBuilder {
      */
     ObservableList<Person> getPersonList();
 
+    /**
+     * Returns an unmodifiable view of the teams list.
+     * This list will not contain any duplicate teams.
+     */
+    ObservableList<Team> getTeamList();
+
 }

src/main/java/teambuilder/model/TeamBuilder.java

@@ -7,6 +7,8 @@
 import javafx.collections.ObservableList;
 import teambuilder.model.person.Person;
 import teambuilder.model.person.UniquePersonList;
+import teambuilder.model.team.Team;
+import teambuilder.model.team.UniqueTeamList;
 
 /**
  * Wraps all data at the address-book level
@@ -27,6 +29,19 @@ public class TeamBuilder implements ReadOnlyTeamBuilder {
         persons = new UniquePersonList();
     }
 
+    private final UniqueTeamList teams;
+
+    /*
+     * The 'unusual' code block below is a non-static initialization block, sometimes used to avoid duplication
+     * between constructors. See https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html
+     *
+     * Note that non-static init blocks are not recommended to use. There are other ways to avoid duplication
+     *   among constructors.
+     */
+    {
+        teams = new UniqueTeamList();
+    }
+
     public TeamBuilder() {}
 
     /**
@@ -93,6 +108,40 @@ public void removePerson(Person key) {
         persons.remove(key);
     }
 
+    //// team-level operations
+
+    /**
+     * Returns true if a team with the same identity as {@code team} exists in the address book.
+     */
+    public boolean hasTeam(Team team) {
+        requireNonNull(team);
+        return teams.contains(team);
+    }
+
+    /**
+     * Adds a team to the address book.
+     * The person must not already exist in the address book.
+     */
+    public void addTeam(Team team) {
+        teams.add(team);
+    }
+
+    /**
+     * Removes {@code key} from this {@code AddressBook}.
+     * {@code key} must exist in the address book.
+     */
+    public void removeTeam(Team key) {
+        teams.remove(key);
+    }
+
+    public void updatePersonInTeams(Person person) {
+        teams.updatePersonInTeams(person);
+    }
+
+    public void removeFromAllTeams(Person person) {
+        teams.removeFromAllTeams(person);
+    }
+
     //// util methods
 
     @Override
@@ -106,6 +155,11 @@ public ObservableList<Person> getPersonList() {
         return persons.asUnmodifiableObservableList();
     }
 
+    @Override
+    public ObservableList<Team> getTeamList() {
+        return teams.asUnmodifiableObservableList();
+    }
+
     @Override
     public boolean equals(Object other) {
         return other == this // short circuit if same object

src/main/java/teambuilder/model/person/Person.java

@@ -149,7 +149,7 @@ public String toString() {
         Set<Tag> teams = getTeams();
         if (!teams.isEmpty()) {
             builder.append("; Teams: ");
-            tags.forEach(builder::append);
+            teams.forEach(builder::append);
         }
         return builder.toString();
     }

src/main/java/teambuilder/model/tag/Tag.java

@@ -33,6 +33,10 @@ public static boolean isValidTagName(String test) {
         return test.matches(VALIDATION_REGEX);
     }
 
+    public String getName() {
+        return tagName;
+    }
+
     @Override
     public boolean equals(Object other) {
         return other == this // short circuit if same object

src/main/java/teambuilder/model/team/Team.java

@@ -5,6 +5,7 @@
 import java.util.HashSet;
 import java.util.Set;
 
+import teambuilder.model.person.Name;
 import teambuilder.model.tag.Tag;
 
 /**
@@ -20,7 +21,7 @@ public class Team {
     private final TeamName teamName;
     private final Desc teamDesc;
     private final Set<Tag> skillTags = new HashSet<>();
-    private final Set<String> members = new HashSet<>();
+    private final Set<Name> members = new HashSet<>();
 
 
     /**
@@ -37,6 +38,34 @@ public Team(TeamName teamName, Desc teamDesc, Set<Tag> skillTags) {
         this.skillTags.addAll(skillTags);
     }
 
+    public TeamName getName() {
+        return this.teamName;
+    }
+
+    /**
+     * Returns true if both teams have the same name.
+     * This defines a weaker notion of equality between two teams.
+     */
+    public boolean isSameTeam(Team otherTeam) {
+        if (otherTeam == this) {
+            return true;
+        }
+
+        return otherTeam != null
+                && otherTeam.getName().equals(getName());
+    }
+
+    public void addPerson(Name name) {
+        members.add(name);
+    }
+
+    public void removePerson(Name name) {
+        members.remove(name);
+    }
+
+    public Set<Name> getMembers() {
+        return members;
+    }
 
     @Override
     public int hashCode() {

src/main/java/teambuilder/model/team/UniqueTeamList.java

@@ -0,0 +1,115 @@
+package teambuilder.model.team;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Iterator;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import teambuilder.model.person.Person;
+import teambuilder.model.tag.Tag;
+import teambuilder.model.team.exceptions.DuplicateTeamException;
+import teambuilder.model.team.exceptions.TeamNotFoundException;
+
+/**
+ * A list of teams that enforces uniqueness between its elements and does not allow nulls.
+ */
+public class UniqueTeamList implements Iterable<Team> {
+
+    private final ObservableList<Team> internalList = FXCollections.observableArrayList();
+    private final ObservableList<Team> internalUnmodifiableList =
+            FXCollections.unmodifiableObservableList(internalList);
+
+    /**
+     * Returns true if the list contains an equivalent team as the given argument.
+     */
+    public boolean contains(Team toCheck) {
+        requireNonNull(toCheck);
+        return internalList.stream().anyMatch(toCheck::isSameTeam);
+    }
+
+    /**
+     * Adds a team to the list.
+     * The team must not already exist in the list.
+     */
+    public void add(Team toAdd) {
+        requireNonNull(toAdd);
+        if (contains(toAdd)) {
+            throw new DuplicateTeamException();
+        }
+        internalList.add(toAdd);
+    }
+
+    /**
+     * Removes the equivalent team from the list.
+     * The team must exist in the list.
+     */
+    public void remove(Team toRemove) {
+        requireNonNull(toRemove);
+        if (!internalList.remove(toRemove)) {
+            throw new TeamNotFoundException();
+        }
+    }
+
+    /**
+     * Add or delete person from TeamList depending on presence or absence of team tag respectively.
+     */
+    public void updatePersonInTeams(Person person) {
+        requireNonNull(person);
+        Object[] allTeamTags = person.getTeams().toArray();
+
+        for (Team team: internalList) {
+            boolean isPresent = false;
+            for (Object tag : allTeamTags) {
+                Tag castedTag = (Tag) tag;
+                if (castedTag.getName().equals(team.toString())) {
+                    team.addPerson(person.getName());
+                    isPresent = true;
+                    break;
+                }
+            }
+            if (!isPresent) {
+                team.removePerson(person.getName());
+            }
+        }
+
+
+    }
+
+    /**
+     * delete person from all teams in TeamList.
+     */
+    public void removeFromAllTeams(Person person) {
+        requireNonNull(person);
+
+        for (Team team: internalList) {
+            team.removePerson(person.getName());
+        }
+
+    }
+
+
+    /**
+     * Returns the backing list as an unmodifiable {@code ObservableList}.
+     */
+    public ObservableList<Team> asUnmodifiableObservableList() {
+        return internalUnmodifiableList;
+    }
+
+    @Override
+    public Iterator<Team> iterator() {
+        return internalList.iterator();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof UniqueTeamList // instanceof handles nulls
+                && internalList.equals(((UniqueTeamList) other).internalList));
+    }
+
+    @Override
+    public int hashCode() {
+        return internalList.hashCode();
+    }
+}

src/main/java/teambuilder/model/team/exceptions/DuplicateTeamException.java

@@ -0,0 +1,11 @@
+package teambuilder.model.team.exceptions;
+
+/**
+ * Signals that the operation will result in duplicate Teams (Teams are considered duplicates if they have the same
+ * name).
+ */
+public class DuplicateTeamException extends RuntimeException {
+    public DuplicateTeamException() {
+        super("Operation would result in duplicate teams");
+    }
+}

src/main/java/teambuilder/model/team/exceptions/TeamNotFoundException.java

@@ -0,0 +1,6 @@
+package teambuilder.model.team.exceptions;
+
+/**
+ * Signals that the operation is unable to find the specified team.
+ */
+public class TeamNotFoundException extends RuntimeException {}

src/main/java/teambuilder/model/util/SampleDataUtil.java

@@ -22,22 +22,23 @@ public static Person[] getSamplePersons() {
         return new Person[] {
             new Person(new Name("Alex Yeoh"), Phone.of("87438807"), Email.of("alexyeoh@example.com"),
                 Address.of("Blk 30 Geylang Street 29, #06-40"), Major.of("Computer Science"),
-                getTagSet("friends"), getTagSet("Team A")),
+                getTagSet("friends"), getTagSet()),
             new Person(new Name("Bernice Yu"), Phone.of("99272758"), Email.of("berniceyu@example.com"),
                 Address.of("Blk 30 Lorong 3 Serangoon Gardens, #07-18"), Major.of("Computer Science"),
-                getTagSet("colleagues", "friends"), getTagSet("Team A", "CS2103T G17")),
+                getTagSet("colleagues", "friends"), getTagSet()),
             new Person(new Name("Charlotte Oliveiro"), Phone.of("93210283"), Email.of("charlotte@example.com"),
                 Address.of("Blk 11 Ang Mo Kio Street 74, #11-04"), Major.of("Computer Science"),
-                getTagSet("neighbours"), getTagSet("Rh Rockers")),
+                getTagSet("neighbours"), getTagSet()),
             new Person(new Name("David Li"), Phone.of("91031282"), Email.of("lidavid@example.com"),
                 Address.of("Blk 436 Serangoon Gardens Street 26, #16-43"), Major.of("Computer Science"),
-                getTagSet("family"), getTagSet("Club penguin")),
+                getTagSet("family"), getTagSet()),
             new Person(new Name("Irfan Ibrahim"), Phone.of("92492021"), Email.of("irfan@example.com"),
                 Address.of("Blk 47 Tampines Street 20, #17-35"), Major.of("Computer Science"),
-                getTagSet("classmates"), getTagSet("RuneScapers")),
+                getTagSet("classmates"), getTagSet()),
             new Person(new Name("Roy Balakrishnan"), Phone.of("92624417"), Email.of("royb@example.com"),
                 Address.of("Blk 45 Aljunied Street 85, #11-31"), Major.of("Computer Science"),
-                getTagSet("colleagues"), getTagSet("Coding is fun club"))
+                getTagSet("colleagues"), getTagSet())
+
         };
     }
 

src/test/java/teambuilder/logic/commands/AddCommandTest.java

@@ -14,7 +14,9 @@
 
 import org.junit.jupiter.api.Test;
 
+import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import javafx.collections.transformation.FilteredList;
 import teambuilder.commons.core.GuiSettings;
 import teambuilder.commons.core.Memento;
 import teambuilder.logic.commands.exceptions.CommandException;
@@ -23,6 +25,7 @@
 import teambuilder.model.ReadOnlyUserPrefs;
 import teambuilder.model.TeamBuilder;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 import teambuilder.testutil.PersonBuilder;
 
 public class AddCommandTest {
@@ -155,11 +158,40 @@ public void setPerson(Person target, Person editedPerson) {
             throw new AssertionError("This method should not be called.");
         }
 
+        @Override
+        public boolean hasTeam(Team team) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void deleteTeam(Team target) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void addTeam(Team team) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void updatePersonInTeams(Person person) {
+            return;
+        }
+
+        @Override
+        public void removeFromAllTeams(Person person) {
+            throw new AssertionError("This method should not be called.");
+        }
+
         @Override
         public ObservableList<Person> getSortedPersonList() {
             throw new AssertionError("This method should not be called.");
         }
 
+        @Override
+        public ObservableList<Team> getTeamList() {
+            return new FilteredList<>(FXCollections.unmodifiableObservableList(FXCollections.observableArrayList()));
+        }
         @Override
         public void updateFilteredPersonList(Predicate<Person> predicate) {
             throw new AssertionError("This method should not be called.");

src/test/java/teambuilder/logic/commands/RedoCommandIntegrationTest.java

@@ -19,6 +19,7 @@
 import teambuilder.model.ReadOnlyTeamBuilder;
 import teambuilder.model.ReadOnlyUserPrefs;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 
 public class RedoCommandIntegrationTest {
     @Test
@@ -164,6 +165,31 @@ public void setPerson(Person target, Person editedPerson) {
             throw new UnsupportedOperationException("Unimplemented method 'setPerson'");
         }
 
+        @Override
+        public boolean hasTeam(Team team) {
+            throw new UnsupportedOperationException("Unimplemented method 'hasTeam'");
+        }
+
+        @Override
+        public void deleteTeam(Team target) {
+            throw new UnsupportedOperationException("Unimplemented method 'deleteTeam'");
+        }
+
+        @Override
+        public void addTeam(Team team) {
+            throw new UnsupportedOperationException("Unimplemented method 'addTeam'");
+        }
+
+        @Override
+        public void updatePersonInTeams(Person person) {
+            throw new UnsupportedOperationException("Unimplemented method 'updatePersonInTeams'");
+        }
+
+        @Override
+        public void removeFromAllTeams(Person person) {
+            throw new UnsupportedOperationException("Unimplemented method 'removeFromAllTeams'");
+        }
+
         @Override
         public ObservableList<Person> getSortedPersonList() {
 
@@ -181,6 +207,11 @@ public void updateSort(Comparator<Person> comparator) {
             throw new UnsupportedOperationException("Unimplemented method 'updateSort'");
         }
 
+        @Override
+        public ObservableList<Team> getTeamList() {
+            throw new AssertionError("This method should not be called.");
+        }
+
     }
 
     private class EmptyMomentoStub implements Memento {

src/test/java/teambuilder/logic/commands/UndoCommandTest.java

@@ -19,6 +19,7 @@
 import teambuilder.model.ReadOnlyTeamBuilder;
 import teambuilder.model.ReadOnlyUserPrefs;
 import teambuilder.model.person.Person;
+import teambuilder.model.team.Team;
 
 public class UndoCommandTest {
     @Test
@@ -172,6 +173,31 @@ public void setPerson(Person target, Person editedPerson) {
             throw new UnsupportedOperationException("Unimplemented method 'setPerson'");
         }
 
+        @Override
+        public boolean hasTeam(Team team) {
+            throw new AssertionError("Unimplemented method 'hasTeam'");
+        }
+
+        @Override
+        public void deleteTeam(Team target) {
+            throw new AssertionError("Unimplemented method 'deleteTeam'");
+        }
+
+        @Override
+        public void addTeam(Team team) {
+            throw new AssertionError("Unimplemented method 'addTeam'");
+        }
+
+        @Override
+        public void updatePersonInTeams(Person person) {
+            throw new AssertionError("Unimplemented method 'updatePersonInTeams'");
+        }
+
+        @Override
+        public void removeFromAllTeams(Person person) {
+            throw new AssertionError("Unimplemented method 'removeFromAllTeams'");
+        }
+
         @Override
         public ObservableList<Person> getSortedPersonList() {
 
@@ -180,7 +206,6 @@ public ObservableList<Person> getSortedPersonList() {
 
         @Override
         public void updateFilteredPersonList(Predicate<Person> predicate) {
-
             throw new UnsupportedOperationException("Unimplemented method 'updateFilteredPersonList'");
         }
 
@@ -189,6 +214,11 @@ public void updateSort(Comparator<Person> comparator) {
             throw new UnsupportedOperationException("Unimplemented method 'updateSort'");
         }
 
+        @Override
+        public ObservableList<Team> getTeamList() {
+            throw new AssertionError("Unimplemented method 'getTeamList'");
+        }
+
     }
 
     private class EmptyMomentoStub implements Memento {

src/test/java/teambuilder/model/TeamBuilderTest.java

@@ -20,6 +20,7 @@
 import javafx.collections.ObservableList;
 import teambuilder.model.person.Person;
 import teambuilder.model.person.exceptions.DuplicatePersonException;
+import teambuilder.model.team.Team;
 import teambuilder.testutil.PersonBuilder;
 
 public class TeamBuilderTest {
@@ -97,6 +98,11 @@ private static class AddressBookStub implements ReadOnlyTeamBuilder {
         public ObservableList<Person> getPersonList() {
             return persons;
         }
+
+        @Override
+        public ObservableList<Team> getTeamList() {
+            throw new AssertionError("This method should not be called.");
+        }
     }
 
 }

src/test/java/teambuilder/model/person/UniqueTeamListTest.java

@@ -0,0 +1,45 @@
+package teambuilder.model.person;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static teambuilder.testutil.Assert.assertThrows;
+import static teambuilder.testutil.TypicalTeams.TEAM_A;
+
+import org.junit.jupiter.api.Test;
+
+import teambuilder.model.team.UniqueTeamList;
+import teambuilder.model.team.exceptions.DuplicateTeamException;
+
+public class UniqueTeamListTest {
+
+    private final UniqueTeamList uniqueTeamList = new UniqueTeamList();
+
+    @Test
+    public void contains_nullTeam_throwsNullPointerException() {
+        assertThrows(NullPointerException.class, () -> uniqueTeamList.contains(null));
+    }
+
+    @Test
+    public void contains_personNotInList_returnsFalse() {
+        assertFalse(uniqueTeamList.contains(TEAM_A));
+    }
+
+    @Test
+    public void contains_personInList_returnsTrue() {
+        uniqueTeamList.add(TEAM_A);
+        assertTrue(uniqueTeamList.contains(TEAM_A));
+    }
+
+    @Test
+    public void add_nullPerson_throwsNullPointerException() {
+        assertThrows(NullPointerException.class, () -> uniqueTeamList.add(null));
+    }
+
+    @Test
+    public void add_duplicatePerson_throwsDuplicatePersonException() {
+        uniqueTeamList.add(TEAM_A);
+        assertThrows(DuplicateTeamException.class, () -> uniqueTeamList.add(TEAM_A));
+    }
+
+
+}

src/test/java/teambuilder/testutil/TypicalTeams.java

@@ -0,0 +1,17 @@
+package teambuilder.testutil;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+import teambuilder.model.tag.Tag;
+import teambuilder.model.team.Desc;
+import teambuilder.model.team.Team;
+import teambuilder.model.team.TeamName;
+
+/**
+ * Sample teams for testing
+ */
+public class TypicalTeams {
+    public static final Team TEAM_A = new Team(new TeamName("Team A"), new Desc("This is Team A"),
+            new HashSet<Tag>(Arrays.asList(new Tag("Python"), new Tag("ReactNative"))));
+}