Teo Jun Xiong - Project Portfolio

The user enters a recipe adding command using the command line input cookbook add recipe n/NAME d/DESCRIPTION [i/INGREDIENT]…​ [q/QUANTITY]…​ [s/STEP_DESCRIPTION]…​ [t/TAG]…​.

CookingPapaParser parses the user input and checks if it is valid. If it is invalid, i.e. an unknown command category, a ParseException will be thrown. If the input is valid, with the command category cookbook, a new CookbookCommandParser is created.

CookbookCommandParser then parses add recipe n/NAME d/DESCRIPTION [i/INGREDIENT]…​ [q/QUANTITY]…​ [s/STEP_DESCRIPTION]…​ [t/TAG]…​. If it is invalid, i.e. an unknown command word, a ParseException will be thrown. If the input is valid, with the command word add, a new CookbookAddCommandParser is created.

CookbookAddCommandParser parses recipe n/NAME d/DESCRIPTION [i/INGREDIENT]…​ [q/QUANTITY]…​ [s/STEP_DESCRIPTION]…​ [t/TAG]…​ and checks if n/NAME and d/DESCRIPTION are provided. If either are not provided, then a ParseException will be thrown.

if (names.size() != quantities.size()) {
    throw new ParseException(
        String.format(MESSAGE_DIFFERENT_NUMBER_OF_INPUTS, names.size(), quantities.size()));
}

These fields are then passed as parameters for Recipe, which is then passed as the parameter for CookbookAddCommand and returned to LogicManager.

LogicManager calls CookbookAddCommand#execute() which checks if the cookbook already contains the same recipe with the same name, description, ingredient names, ingredient quantities, and tags using Model#hasCookbookRecipe().

if (model.hasCookbookRecipe(toAdd)) {
    throw new CommandException(MESSAGE_DUPLICATE_RECIPE);
}

If CommandException is not thrown, Model#addCookbookRecipe will be executed, with the recipe to be added as a parameter.

Model#addCookbookRecipe() then executes Cookbook#addRecipe(), which adds the recipe to the cookbook, and the FilteredList<Recipe> representing the recipes in the cookbook are updated with Model#updateFilteredCookbookRecipeList():

updateFilteredCookbookRecipeList(PREDICATE_SHOW_ALL_RECIPES)

A CommandResult with the text to display to the user is then returned to LogicManager, which can passed back to MainWindow, which displays it to the user on the CLI and GUI: resultDisplay.setFeedbackToUser(commandResult.getFeedbackToUser()). The text displayed will notify the user on whether their addition was successful.

The user enters a cart export command using the command line input cart export.

CookingPapaParser parses the user input and checks if it is valid. If it is invalid, i.e. an unknown command category, a ParseException will be thrown. If the input is valid, with the command category cart, a new CartCommandParser is created.

CartCommandParser then parses export. If it is invalid, i.e. an unknown command word, a ParseException will be thrown. If the input is valid, with the command category export, a new CookbookExportCommandParser is created.

CartExportCommandParser parses the user input and checks if the argument passed to it is an empty String, as the command takes in no extra parameters.

if (userInput.isEmpty()) {
    return new CartExportCommand();
} else {
    throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, CartExportCommand.MESSAGE_USAGE));
}

CartExportCommandParser then returns a CartExportCommand to LogicManager.

LogicManager calls CartExportCommand#execute() calls the static method of PdfExporter, PdfExporter#exportCart(), which takes in the ObservableList<Ingredient> stored in Cart

Step 4 is executed within a try-catch block. If a previously generated pdf (saved as cart.pdf by default) is opened in another program, or there is an issue writing to the PDF file, a CommandResult with an error message will returned to LogicManager (skipping step 7 and 8):

try {
    PdfExporter.exportCart(model.getCart().getIngredientList());
} catch (IOException e) {
    return new CommandResult(MESSAGE_FILE_NOT_FOUND);
}

The ingredients in the Cart is passed to the static method PdfExporter#exportCart(), which then makes use of the library, PDFbox, to parse the data.

Within PdfExporter, PdfExporter#getTextFromCart parse the data and splits them manually, in order to wrap the text (this has to be done due to the inadequacy of PDFbox). The method returns a List<String>, where each string represents a new line on the PDF file.

Subsequently, PdfExporter checks if the number of String s in the list in step 7 is greater than the number of lines a single page of the PDF can accomodate. If it is, it adds a new page, and adds lines to the PDF until the limit is hit. This repeats until all the lines are added to the PDF.

A CommandResult with the text to display to the user will be returned to LogicManager. The CommandResult is then passed back to MainWindow, which displays it to the user on the CLI and GUI: resultDisplay .setFeedbackToUser(commandResult.getFeedbackToUser()). The text displayed will notify the user on whether their addition was successful.

The user enters a view recipe command using the command line input cookbook view recipe INDEX.

CookingPapaParser parses the user input and checks if it is valid. If it is invalid, i.e. an unknown command category, a ParseException will be thrown. If the input is valid, with the command category cookbook, a new CookbookCommandParser is created.

CookbookCommandParser then parses view recipe INDEX. If it is invalid, i.e. an unknown command word, a ParseException will be thrown. If the input is valid, with the command category view, a new CookbookViewCommandParser is created.

CookbookViewCommandParser then parses recipe INDEX and checks if the String contains "recipe", and an index. If either are absent, a ParseException will be thrown. If the String is valid, a CookbookView is created.

CookbookViewCommandParser then returns a CookbookViewCommand to LogicManager.

LogicManager calls CookbookViewCommand#execute() which checks if the provided Index is within the bounds of the FilteredCookbookRecipeList() in Cookbook, i.e. index.getZeroBased() >= list.size(). If it is not, a CommandException will be thrown. If it is valid, a CommandResult is created with a boolean value true.

A CommandResult with the text to display to the user will be returned to LogicManager. The CommandResult is then passed back to MainWindow. The boolean value stated in step 6 determines whether a successfully parsed command is a cookbook view recipe INDEX command.

MainWindow#handleViewRecipe is then executed, which creates a new CookbookPanel with the same set of data, calling CookbookPanel#handleViewRecipe, which creates new RecipeCard s for Cookbook, and for the RecipeCard that has an index equal to the index processed from the user’s input, it will create a RecipeCard that toggles open the recipe details. More on how the RecipeCard manages this will be discussed in the following section on how clicking on a button in the GUI has the same effect as the cookbook view recipe INDEX command.

Lastly, the user then is shown a CookbookPanel with the selected recipe toggled open, which displays the full details of that recipe:

When the button is pressed, the onAction method, RecipeCard#handleViewButtonAction() is executed. A RecipeCard has a variable isFullyDisplayed, which indicates whether it is displaying an overview of the recipe, or fully displaying details of the recipe.

If isFullyDisplayed is false, i.e. the RecipeCard is currently displaying an overview of the recipe, RecipeCard#displayRecipeComplete() is executed, which replaces the text displayed by the FXML object, Label, with the full details of the recipe.

If isFullyDisplayed is true, i.e. the RecipeCard is currently fully displaying the details of the recipe, RecipeCard#displayRecipeOverview() is executed, which replaces the text displayed by the FXML object, Label with the overview of the recipe.

Both methods executed in step 3 and 4 will flip the boolean value of isFullyDisplayed, and this means that the next time the button for the same recipe is clicked, it toggles back. For example, if a recipe with its overview shown has its view button clicked, it will show the full details of the recipe. If the button is clicked again, it toggles, and shows the overview of the recipe.