Cooking Papa - Developer Guide

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 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.

The user adds a ingredient to the cart by entering the command cart add ingredient i/INGREDIENT_NAME q/INGREDIENT_QUANTITY in the command line input.

CartAddCommandParser parsers the input to check and verify that the input provided for i/INGREDIENT_NAME amd q/INGREDIENT_QUANTITY are correct. Otherwise a ParseException will be thrown.

The fields are then passed to CartAddIngredientCommand as an Ingredient object and is returned to LogicManager.

LogicManager calls CartAddIngredientCommand#execute() and checks if the Ingredient object given has the same INGREDIENT_NAME and INGREDIENT_QUANTITY unit. If that Ingredient exists, it will simply add on to the quantity of that ingredient. Otherwise, a new instance of that Ingredient will be added to the Cart.

If CommandException is not thrown, Model#addCartIngredient will be executed, with the given Ingredient as the parameter

Model#addCartIngredient then executes, adding the Ingredient to the local cart storage and updates with Model#updateFilteredCartIngredientList().

A CommandResult with the successful text message is returned to LogicManager and will be displayed to the user via the GUI to feedback to the user that the Ingredient has been successfully added.

The user enters an inventory cook command inventory cook recipe INDEX using the command line input.

InventoryCookCommandParser parses the input to check and verify the input provided by the user. If the input provided is invalid, a ParseException will be thrown.

The valid index is then passed to InventoryCookCommand as an Index object.

LogicManager calls InventoryCookCommand#execute() and checks if the Index provided is within bounds and if the specified Recipe contains ingredients. Otherwise, a CommandException is thrown.

Subsequently, two checks are performed to check if the inventory contains all of the ingredients specified and whether those quantities are sufficient to be subtracted.

If all the checks passed, model#removeInventoryIngredient is called through a stream() to remove the ingredients of a selected recipe from the inventory.

selectedRecipe.getIngredients().stream().forEach(model::removeInventoryIngredient);

A CommandResult with a success message is returned to LogicManager and passed back to MainWindow which displays the text to the user through the GUI.

The user enters the command cart move in to the command line input.

CartMoveCommandParser then ensures that the user does not enter any other commands after cart clear.

CartMoveCommandParser then returns a CartMoveCommand and returns it to LogicManager

LogicManager calls CartMoveCommand#execute(). If there are other commands after cart clear, a CommandException will be thrown.

If CommandException is not thrown, Model#cartMoveIngredients() will be executed.

Model#cartMoveIngredients() will move every ingredient from the cart and add it into the inventory

A CommandResult with the success message text will be returned to LogicManager, which will then be passed to MainWindow and will then feedback to the user.

The user enters the command cart add recipe INDEX in the command line input.

CartAddRecipeIngredientParser parses the user input and checks if the index provided is an integer. Note that the parser will throw a ParseException if the given index is not an integer.

try {
    recipeIndex = ParserUtil.parseIndex(argMultimap.getPreamble());
} catch (ParseException pe) {
    throw new ParseException(String.format(MESSAGE_INVALID_RECIPE_DISPLAYED_INDEX, CartAddCommand.MESSAGE_USAGE), pe);
}

The index is passed as a parameter for CartAddRecipeIngredientCommand which is returned to LogicManager.

LogicManager calls CartAddRecipeIngredientCommand#execute() which checks if the given index is a valid index of a recipe. Note that the command will throw a CommandException if the given index is not valid.

if (recipeIndex.getZeroBased() >= model.getCookbook().getRecipeList().size()) {
    throw new CommandException(String.format(MESSAGE_INVALID_RECIPE_DISPLAYED_INDEX, MESSAGE_USAGE));
}

If the index is valid, the selected recipe’s ingredients will be added accordingly. This is done through calling Model#addCartIngredient(), with each ingredient as the parameter.

Model#addCartIngredient calls Cart#addIngredident() which then adds the ingredient to the cart. If a certain ingredient exists in the cart, adding a ingredient to a cart will increase the quantity instead. Otherwise, a new instance of that ingredient will be added to the cart. After adding an ingredient, the cart will be updated with Model#updateFilteredCartIngredientList().

A CommandResult with the successful text message is returned to LogicManager and will be displayed to the user via the GUI to feedback to the user that the selected recipe’s ingredients has been successfully added to the cart.

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.