Khoo Wei Ping - Project Portfolio

public void sortBy(String order) throws IllegalArgumentException {
    switch (order) {
    case "name":
        internalList.sort((Person p1, Person p2) -> p1.getName().compareTo(p2.getName()));
        break;
    case "debt":
        internalList.sort((Person p1, Person p2) -> p2.getDebt().compareTo(p1.getDebt()));
        break;
    case "cluster":
        internalList.sort((Person p1, Person p2) -> p1.getCluster().compareTo(p2.getCluster()));
        break;
    case "deadline":
        internalList.sort((Person p1, Person p2) -> p1.getDeadline().compareTo(p2.getDeadline()));
        internalList.sort((Person p1, Person p2) -> Boolean.compare(p1.isWhitelisted(), p2.isWhitelisted()));
        break;
    default:
        throw new IllegalArgumentException("Invalid sort ordering");
    }
}

public class SortCommandParser implements Parser<SortCommand> {
    public SortCommand parse(String args) throws ParseException {
        requireNonNull(args);
        String trimmedArgs = args.trim().toLowerCase();
        switch (trimmedArgs) {
        case "":
        case "name":
        case "debt":
        case "cluster":
        case "deadline":
            return new SortCommand(trimmedArgs);
        default:
            throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, SortCommand.MESSAGE_USAGE));
        }
    }
}

public static final String DEFAULT_ORDERING = "name";

public SortCommand(String order) {
    //validity of order to sort is checked in {@code SortCommandParser}
    if (order.equals("")) {
        order = DEFAULT_ORDERING;
    }
    this.order = order;
}

public CommandResult execute() throws CommandException {
    try {
        model.sortBy(order);
    } // irrelevant parts of the method omitted for brevity
}

public Person(Name name, Phone phone, Email email, Address address, PostalCode postalCode,
              Debt debt, Interest interest, Deadline deadline, Set<Tag> tags) {
    requireAllNonNull(name, phone, email, address, postalCode, debt, interest, deadline, tags);
    // assignment of other fields omitted for brevity
    this.cluster = new SimpleObjectProperty<>(new Cluster(postalCode));
}

public Cluster(PostalCode postalCode) {
    requireNonNull(postalCode);
    if (!isValidPostalCode(postalCode.toString())) {
        throw new AssertionError(MESSAGE_POSTAL_CODE_CONSTRAINTS);
    }
    String cluster = getCluster(postalCode.toString());
    clusterNumber = Integer.parseInt(cluster.substring(0, 2));
    this.value = cluster.substring(4);
}

public class ClusterUtil {

    public static final String CLUSTER_POSTAL_DISTRICT_01 = "01. Raffles Place, Cecil, Marina, People's Park";
    // declaration of other postal districts omitted for brevity
    public static final String CLUSTER_POSTAL_DISTRICT_UNKNOWN = "99. Unknown";

    public static String getCluster(String postalCode) {
        requireNonNull(postalCode);
        int postalSector = Integer.parseInt(postalCode.substring(0, 2));
        switch (postalSector) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
            return CLUSTER_POSTAL_DISTRICT_01;
        // cases for all other valid postal districts omitted for brevity
        default:
            return CLUSTER_POSTAL_DISTRICT_UNKNOWN;
        }
    }
}

public RepaidCommand parse(String args) throws ParseException {
    try {
        if (args.trim().equals("")) {
            return new RepaidCommand();
        } else {
            Index index = ParserUtil.parseIndex(args);
            return new RepaidCommand(index);
        }
    } catch (IllegalValueException ive) {
        throw new ParseException(
            String.format(MESSAGE_INVALID_COMMAND_FORMAT, RepaidCommand.MESSAGE_USAGE));
    }
}

public RepaidCommand() throws CommandException {
    personToWhitelist = selectPersonForCommand();
}

public RepaidCommand(Index targetIndex) throws CommandException {
    personToWhitelist = selectPersonForCommand(targetIndex);
}

public ReadOnlyPerson selectPersonForCommand() throws CommandException {
    if (ListObserver.getSelectedPerson() == null) {
        throw new CommandException(Messages.MESSAGE_NO_PERSON_SELECTED);
    }
    return ListObserver.getSelectedPerson();
}

public ReadOnlyPerson selectPersonForCommand(Index index) throws CommandException {
    List<ReadOnlyPerson> lastShownList = ListObserver.getCurrentFilteredList();
    if (index.getZeroBased() >= lastShownList.size()) {
        throw new CommandException(Messages.MESSAGE_INVALID_PERSON_DISPLAYED_INDEX);
    }
    return lastShownList.get(index.getZeroBased());
}

private void changeTheme() {
    for (String stylesheet : getRoot().getStylesheets()) {
        if (stylesheet.endsWith("DarkTheme.css")) {
            getRoot().getStylesheets().remove(stylesheet);
            getRoot().getStylesheets().add("/view/BrightTheme.css");
            break;
        } else if (stylesheet.endsWith("BrightTheme.css")) {
            getRoot().getStylesheets().remove(stylesheet);
            getRoot().getStylesheets().add("/view/DarkTheme.css");
            break;
        }
    }
}

@Subscribe
private void handleChangeThemeRequestEvent(ChangeThemeRequestEvent event) {
    logger.info(LogsCenter.getEventHandlingLogMessage(event));
    changeTheme();
}

public CommandResult execute() {
    EventsCenter.getInstance().post(new ChangeThemeRequestEvent());
    return new CommandResult(MESSAGE_SUCCESS);
}