I want to make sure that the code is correct in terms of its design, code correctness, best practices & Junit testing.
The complete description is given below:
Functioning of the app quickly estimates the Final Cost depending on different markups. The following are the markups:
- Flat Markup of 5% on all jobs
- Markup of 1.2% for per Working person
- Type of materials markup:
- For pharmaceuticals, 7.5% markup
- For food, 13% markup
- For electronics,2% markup
- For everything else, No markup
The markup calculator should accept the initial base price along with the different categories of markups and calculate a final cost for a project. Example:
Input 1: $1299.99
3 people
food
Output 1: $1591.58
The app is designed like a MVC (Model view controller) logic app where the Model is used to store the data & perform calculations, Controller acts as the getter & setter for values from user & View is used to print the final input & output to the user as MVC format helps any developer to understand the structure & can also embed this app into another MVC app for use
MainCalculator
public class MainCalculator { //BASE PRICE private static String BASE_PRICE="$1299.99"; //Number of People private static String NUM_OF_PEOPLE= "3 people"; //Types of materials private static String TYPE_OF_MATERIAL[] = new String[]{"FOOD","food"}; //Error messages are stored in this private static String message; //status remains true if validation for error checking passes the test i.e. program has handled all test cases private static boolean status= true; /* * MSG_ARGUMENT_NULL, MSG_INVALID_BASE_PRICE, MSG_INVALID_NUM_OF_PEOPLE, MSG_INSUFFICIENT_ARGUMENTS are the messages * displayed when a particular test case fails in the below methodsS * */ //@param MSG_ARGUMENT_NULL is printed when validateNullArgument() returns false private static final String MSG_ARGUMENT_NULL = "Mandatory inputs cannot be null, <BASE_PRICE>, <NUM_OF_PEOPLE> is mandatory"; private static final String MSG_ARGUMENT_NULL_TYPE_OF_MATERIAL = "One of the arguments is null in <Type of Material>"; //@param MSG_INSUFFICIENT_ARGUMENTS is printed when validateEmptyArgument() returns false private static final String MSG_INSUFFICIENT_ARGUMENTS = "Insufficient number of values <BASE PRICE>, <NUM OF PEOPLE>, <TYPE OF MATERIAL>(Optional)"; //@param MSG_INVALID_BASE_PRICE and/or MSG_INVALID_NUM_OF_PEOPLE is printed when validateNumberFormat() returns false private static final String MSG_INVALID_VALUE = "The <BASE PRICE>/<NUM OF PEOPLE> is not in correct number format"; //System error code 1 denotes invalid argument from user private static final int SYSTEM_ERROR_CODE_INVALID_INPUT = 1; //Main function instantiates the default constructor public static void main(String[] args) { //Default Constructor MarkupController markupControllerObject = new MarkupController(); //sets base price from MarkupController's setter method markupControllerObject.setBasePrice(BASE_PRICE); //sets number of people from MarkupController's setter method markupControllerObject.setNumOfPeople(NUM_OF_PEOPLE); /* * sets the types of materials from MarkupControllers setter method & is a array as multiple types * of materials can be involved */ for(int i=0;i< TYPE_OF_MATERIAL.length;i++) { markupControllerObject.setTypeOfMaterial(TYPE_OF_MATERIAL); } //gets base price from MarkupController's getter method BASE_PRICE = markupControllerObject.getBasePrice(); //gets number of people from MarkupController's getter method NUM_OF_PEOPLE = markupControllerObject.getNumOfPeople(); /* * Gets the types of materials from MarkupControllers getter method & is a array as multiple types * of materials can be involved */ for(int i=0;i< markupControllerObject.getTypeOfMaterial().length;i++) { TYPE_OF_MATERIAL = markupControllerObject.getTypeOfMaterial(); } //checks if the values in constructor are valid otherwise exits system if(!validateNullArgument(BASE_PRICE,NUM_OF_PEOPLE,TYPE_OF_MATERIAL) || !MainCalculator.validateEmptyArgument(BASE_PRICE,NUM_OF_PEOPLE) || !MainCalculator.validateNumberFormat(BASE_PRICE, NUM_OF_PEOPLE)) { //System must exit if any of the conditions are true in if condition exit(SYSTEM_ERROR_CODE_INVALID_INPUT); } else { /* * Removes $ sign & whitespace from Base Price if present * and returns only the double value */ BASE_PRICE = validateDollarCheck(BASE_PRICE); /* * Removes keyword 'people' & whitespace from Number of * people if present & returns only number */ NUM_OF_PEOPLE = validateNumOfPeopleKeyword(NUM_OF_PEOPLE); MarkupModel.calculateMarkupSystemFormula(BASE_PRICE, NUM_OF_PEOPLE, TYPE_OF_MATERIAL); } } //Validates if BASE PRICE OR NUMBER OF PEOPLE or TYPE OF MATERIAL is NULL public static boolean validateNullArgument(String BASE_PRICE,String NUM_OF_PEOPLE, String[] TYPE_OF_MATERIAL) { //sizeTypeOfMaterial is the length of TYPE_OF_MATERIAL int sizeTypeOfMaterial = TYPE_OF_MATERIAL.length; //countNullCheck counts the number of null arguments in the string array of type of material int countNullCheck=0; for(int i=0;i< sizeTypeOfMaterial;i++) { if(TYPE_OF_MATERIAL[i] == null) { countNullCheck++; } } /* * If one of the arguments in string array "Type of Material" * is null, prints an error to the user but continues execution */ if(countNullCheck > 0) { message = MSG_ARGUMENT_NULL_TYPE_OF_MATERIAL; System.out.println(message); } //if countNullCheck is equal to size of type of material which means all elements in array are null if(BASE_PRICE == null || NUM_OF_PEOPLE == null || TYPE_OF_MATERIAL == null || countNullCheck == sizeTypeOfMaterial) { message = MSG_ARGUMENT_NULL; System.out.println(message); return false; } return status; } /* * Validates if BASE PRICE OR NUMBER OF PEOPLE IS EMPTY * If empty, then returns a message or returns true */ public static boolean validateEmptyArgument(String BASE_PRICE, String NUM_OF_PEOPLE) { if(BASE_PRICE.isEmpty() || NUM_OF_PEOPLE.isEmpty()) { message = MSG_INSUFFICIENT_ARGUMENTS; System.out.println(message); return false; } return status; } //Validates if BASE PRICE OR NUMBER OF PEOPLE Is in valid format public static boolean validateNumberFormat(String BASE_PRICE, String NUM_OF_PEOPLE) { /* * Removes $ sign & whitespace from Base Price if present * and returns only the double value */ BASE_PRICE = validateDollarCheck(BASE_PRICE); /* * Removes keyword 'people' & whitespace from Number of * people if present & returns only number */ NUM_OF_PEOPLE = validateNumOfPeopleKeyword(NUM_OF_PEOPLE); /* * If base price is a proper double value & number of people is a proper integer * else throw exception */ try { Double.parseDouble(BASE_PRICE); Integer.parseInt(NUM_OF_PEOPLE); } catch(NumberFormatException exception) { message = MSG_INVALID_VALUE; System.out.println(message); return false; } return status; } //validates if a '$' sign is in front of Base Price & trims it public static String validateDollarCheck(String BASE_PRICE) { if(BASE_PRICE.length() > 0) { if(BASE_PRICE.charAt(0) == '$') { BASE_PRICE = BASE_PRICE.trim().substring(1); } } return BASE_PRICE; } //Validates if user enters 'Number of people' as '8 people' & removes keyword people with whitespace public static String validateNumOfPeopleKeyword(String NUM_OF_PEOPLE) { //Regular expression where s* removes whitespace & \b checks for people String regexPeople = "\\s*\\bpeople\\b\\s*"; //Regular expression where s* removes whitespace & \b removes 'person' String regexPerson = "\\s*\\bperson\\b\\s*"; NUM_OF_PEOPLE = NUM_OF_PEOPLE.replaceAll(regexPeople, "").replaceAll(regexPerson, ""); return NUM_OF_PEOPLE; } //Exits the system public static void exit(int status) { System.exit(status); } } MarkupController
public class MarkupController { /** * MarkupController acts as a library for getter & setter methods for * BASE_PRICE, NUM_OF_PEOPLE and TYPE_OF_MATERIAL * * @author Ankita Kulkarni */ private String BASE_PRICE; private String NUM_OF_PEOPLE; private String[] TYPE_OF_MATERIAL; /*Constructor with 3 parameters * @param BASE_PRICE base price of the system * @param NUM_OF_PEOPLE number of people in the system * @param TYPE_OF_MATERIAL type of materials in the system, an array since user can enter multiple materials */ public MarkupController() { } public MarkupController(String BASE_PRICE, String NUM_OF_PEOPLE,String[] TYPE_OF_MATERIAL) { this.BASE_PRICE = BASE_PRICE; this.NUM_OF_PEOPLE = NUM_OF_PEOPLE; this.TYPE_OF_MATERIAL= TYPE_OF_MATERIAL; } //gets the base Price public String getBasePrice() { return this.BASE_PRICE; } //sets the base Price public void setBasePrice(String BASE_PRICE) { this.BASE_PRICE = BASE_PRICE; } //gets the Number of people public String getNumOfPeople() { return NUM_OF_PEOPLE; } //sets the number of people public void setNumOfPeople(String NUM_OF_PEOPLE) { this.NUM_OF_PEOPLE = NUM_OF_PEOPLE; } //Gets the array of types of material public String[] getTypeOfMaterial() { return TYPE_OF_MATERIAL; } //Sets the array of types of material public void setTypeOfMaterial(String[] TYPE_OF_MATERIAL) { this.TYPE_OF_MATERIAL= TYPE_OF_MATERIAL; } } MarkupModel
import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Set; import java.math.BigDecimal; import code.MarkupView; public class MarkupModel { /** * MarkupModel acts as a Model where it stores values of the system obtained from * MarkupController & performs calculations * @Author Ankita Kulkarni */ //Flat Markup on all jobs is 5% private static final String FLAT_MARKUP_ALL_JOBS = "0.05"; //For each working person, markup is 1.2% private static final String MARKUP_PER_WORKING_PERSON = "0.012"; /* * HashMap stores <key,value> pairs where key is the type of material & value is * its respective percentage markup * Used HashMap as its easy to lookup any existing value stored in HashMap * Runtime Complexity of finding a element is O(1) hence faster */ public static HashMap<String,String> markupTypeOfMaterials = new HashMap<String,String>(){ { // puts <key,value> in HashMap i.e. <type of material,markup Percent> put("pharmaceuticals", "0.075"); put("drugs", "0.075"); put("food", "0.13"); put("electronics", "0.02"); } }; //FlatMarkup is stored in a Big Decimal object as its a decimal value private static BigDecimal getFlatMarkup() { return new BigDecimal(FLAT_MARKUP_ALL_JOBS); } //Markup for every working person is stored in a Big Decimal object for calculations private static BigDecimal getMarkupPerWorkingPerson() { return new BigDecimal(MARKUP_PER_WORKING_PERSON); } /* * @param TYPE_OF_MATERIAL provides type of material string array from user * This method checks if any key of hashmap matches to a key provided by user & only returns * that key */ public static BigDecimal getMarkupTypeOfMaterialsValues(String TYPE_OF_MATERIAL) { /* * containsKey() checks if there is any matching key in hashmap & TYPE_OF_MATERIAL * toLowerCase() all keys in Type of material is converted to lower case to match the * hashmap key example: FOOD and food are identical materials */ if(markupTypeOfMaterials.containsKey(TYPE_OF_MATERIAL.toLowerCase())) { //Only matched key is returned return new BigDecimal(markupTypeOfMaterials.get(TYPE_OF_MATERIAL.toLowerCase())); } //If key doesn't match, 0 is returned as there is 'No- Markup' return new BigDecimal("0"); } /* * Calculates the main functionality of the system * */ public static String calculateMarkupSystemFormula(String BASE_PRICE, String NUM_OF_PEOPLE, String[] TYPE_OF_MATERIAL) { /* * Removes $ sign & whitespace from Base Price if present * and returns only the double value */ BASE_PRICE = MainCalculator.validateDollarCheck(BASE_PRICE); /* * Removes keyword 'people' & whitespace from Number of * people if present & returns only number */ NUM_OF_PEOPLE = MainCalculator.validateNumOfPeopleKeyword(NUM_OF_PEOPLE); /* * Converts base price, number of people into BigDecimal for * calculations */ BigDecimal basePrice = new BigDecimal(BASE_PRICE); BigDecimal numOfPeople = new BigDecimal(NUM_OF_PEOPLE); /* * The elements from Type of materials are added in a Set as * it helps remove duplicates * for eg: In condition like 'food' and 'food', only 1 type * 'food' markup will be calculated */ Set<String> typeOfMaterialSet = null; for(String element:TYPE_OF_MATERIAL) { //Only adds elements which are not empty or not null to the Set if(!element.isEmpty() && element !=null) { typeOfMaterialSet = new HashSet<String>(Arrays.asList(element)); } } //When Type of Material does not match hashmap keys then '0' is added BigDecimal totalTypeOfMaterialMarkup = new BigDecimal("0"); /* * Only those elements from Type of material that match * the hashmap keys are added for calculations */ for(String typeOfMaterial:typeOfMaterialSet) { BigDecimal typeOfMaterialMarkup = getMarkupTypeOfMaterialsValues(typeOfMaterial); totalTypeOfMaterialMarkup = totalTypeOfMaterialMarkup.add(typeOfMaterialMarkup); } /* * Formula for calculating flat markups on all jobs * newBasePrice = basePrice * FlatMarkup (0.05)+ basePrice */ BigDecimal newBasePrice = basePrice.multiply(getFlatMarkup()).add(basePrice); /* * Formula for calculating the markup for the number of people * Markup for working people = num of people * markup per working person (0.012) */ BigDecimal totalMarkupForWorkingPeople = numOfPeople.multiply(getMarkupPerWorkingPerson()); /* * Formula for Final Base Price is: * finalbaseprice = newBasePrice * (1+totalMarkupForWorkingPeople+totalTypeOfMaterialMarkup) * */ BigDecimal finalBasePrice = newBasePrice.multiply(BigDecimal.ONE. add(totalMarkupForWorkingPeople). add(totalTypeOfMaterialMarkup)); /* * returns the final base price by rounding upto 2 digits after decimal along with '$' sign */ MarkupView.printInput(basePrice, numOfPeople, typeOfMaterialSet); String outputBasePrice = MarkupView.printOutputFormat(finalBasePrice); System.out.println("Final Output: "+outputBasePrice); return outputBasePrice; } } MarkupView
import java.math.BigDecimal; import java.util.Set; /** * MarkupView is responsible for displaying the final output to the user * It formats the input & output to provide a clean UI to the user * @author Ankita Kulkarni * */ public class MarkupView { /* * This method formats the basePrice by rounding the 2 numbers after decimal using ROUND_HALF_UP * BigDecimal ROUND_HALF_UP is the ideal way for performing monetary calculations * & ROUND_HALF_UP providing the least bias is recommended * @link http://www.javapractices.com/topic/TopicAction.do?Id=13 */ public static String printOutputFormat(BigDecimal basePrice) { /* * Sets scale of base price to 2 decimal round half up * example, 1591.5777570 turns to 1591.58 */ BigDecimal finalBasePrice = basePrice.setScale(2, BigDecimal.ROUND_HALF_UP); //Prepends '$' sign to base price for representing money String dollarBasePrice = "$"+finalBasePrice.toString(); return dollarBasePrice; } /** * * @param basePrice gets base price that was entered by user * @param numOfPeople gets number of people that was entered by user * @param typeOfMaterial gets the type of material * This method prints all the parameters values on the console along with the * final base price * */ public static void printInput(BigDecimal basePrice,BigDecimal numOfPeople, Set<String> typeOfMaterial) { System.out.println("Base Price: $"+basePrice); System.out.println("Number of People: "+numOfPeople); System.out.println("Type of Material: "+typeOfMaterial.toString().replaceAll("\\[", "").replaceAll("\\]", "") +" "); } } 
