Merge 4809d82a80c74d94f7333975f429733a900606b0 into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

pom.xml

@@ -7,6 +7,18 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>PainfullAfternoon</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

src/main/java/io/zipcoder/ItemParseException.java

@@ -1,4 +1,5 @@
 package io.zipcoder;
 
 public class ItemParseException extends Exception {
+
 }

src/main/java/io/zipcoder/ItemParser.java

@@ -1,31 +1,99 @@
 package io.zipcoder;
 
+import com.sun.org.apache.xerces.internal.impl.xpath.regex.Match;
+
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
 
+    public int errorCount = 0;
+
+    // 1
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
+        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+    }
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    // 2
+    public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    // 3
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
+        String stringPattern = "[@|^|*|%|!|;]";
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
+        return response;
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
-        return response;
+    // 4
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException { // need addtnl.. methods to check info
+
+        String name = checkName(rawItem);
+        Double price = Double.valueOf(checkPrice(rawItem));
+        String type = checkType(rawItem);
+        String expiration = checkExpiration(rawItem);
+
+
+        return new Item(name, price, type, expiration);
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+    public String checkName(String input) throws ItemParseException {
+        Pattern patternName = Pattern.compile("([Nn]..[Ee]:)(\\w+)");
+        Matcher matcherName = patternName.matcher(input);
+
+        if (matcherName.find())         // find() will search substrings
+            return matcherName.group(2).toLowerCase();
+        else throw new ItemParseException();
     }
 
+    public String checkPrice(String input) throws ItemParseException {
+        Pattern patternPrice = Pattern.compile("([Pp]...[Ee]:)(\\d\\.\\d{2})");
+        Matcher matcherPrice = patternPrice.matcher(input);
 
+        if (matcherPrice.find())
+            return matcherPrice.group(2);
+        else throw new ItemParseException();
+    }
+
+    public String checkType(String input) throws ItemParseException {
+        Pattern patternType = Pattern.compile("([Tt]..[Ee]:)(\\w+)");
+        Matcher matcherType = patternType.matcher(input);
+
+        if (matcherType.find())
+            return matcherType.group(2).toLowerCase();
+        else throw new ItemParseException();
+    }
+
+    public String checkExpiration(String input) throws ItemParseException {
+        Pattern patternExpiration = Pattern.compile("([Ee]........[Nn]:)(\\d\\/\\d{2}\\/\\d{4})");
+        Matcher matcherExpiration = patternExpiration.matcher(input);
+
+        if (matcherExpiration.find())
+            return matcherExpiration.group(2);
+        else throw new ItemParseException();
+    }
+
+    public String fixString(String item) {
+        if (item.equals("")) {
+            errorCount++;
+            return "Error";
+        }
+        if (item.startsWith("c")) {
+            item = item.replace("0", "o");
+        }
+        return item.substring(0, 1).toUpperCase() + item.substring(1);
+    }
+
+    public double fixPrice(String price) {
+        if (price.equals("")) {
+            return 0.0;
+        }
+        return Double.parseDouble(price);
+    }
 
 }

src/main/java/io/zipcoder/Main.java

@@ -2,18 +2,118 @@ package io.zipcoder;
 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
 
 public class Main {
 
-    public String readRawDataToString() throws Exception{
+    public String readRawDataToString() throws Exception {
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
         return result;
     }
 
-    public static void main(String[] args) throws Exception{
+    public static void main(String[] args) throws Exception {
         String output = (new Main()).readRawDataToString();
         System.out.println(output);
         // TODO: parse the data in output into items, and display to console.
+
+        ItemParser itemParser = new ItemParser();
+
+        ArrayList<String> itemList = itemParser.parseRawDataIntoStringArray(output);
+
+        ArrayList<Item> items = new ArrayList<Item>();
+        for (String item : itemList) {
+            items.add(itemParser.parseStringIntoItem(item));
+        }
+
+        int errorCounter = 0;
+        Integer milkCounter = 0;
+
+        Iterator<Item> iterator = items.iterator();
+        while (iterator.hasNext()) {
+            Item item = iterator.next();
+            if ("N/A".equals(item.getName()) || item.getPrice() == 0.0) {
+                errorCounter++;
+                iterator.remove();
+            }
+        }
+
+
+        HashMap<String, Integer> names = getNameMap(items);
+
+        for (Map.Entry<String, Integer> name : names.entrySet()) {
+            HashMap<String, HashMap<Double, Integer>> namePriceMap = getNamePriceMap(items, name.getKey());
+
+            System.out.println("==============================");
+            System.out.println("Name: " + name.getKey() + " Appears: " + name.getValue() + " times");
+            System.out.println("------------------------------");
+
+            for (Map.Entry<String, HashMap<Double, Integer>> namePrice : namePriceMap.entrySet()) {
+                String key = namePrice.getKey();
+                for (Map.Entry<Double, Integer> priceMap : namePrice.getValue().entrySet()) {
+                    System.out.println("Price: " + priceMap.getKey() + " Appears: " + priceMap.getValue());
+                }
+
+
+            }
+        }
+        System.out.println("------------------------------");
+        System.out.println("Errors: " + errorCounter);
+
+
+    }
+
+
+    public static HashMap<String, HashMap<Double, Integer>> getNamePriceMap(ArrayList<Item> items, String itemName) {
+
+        HashMap<String, HashMap<Double, Integer>> namePriceMap = new HashMap<>();
+
+        ArrayList<Item> nameList = new ArrayList<>();
+
+        for (Item item : items) {
+            if (item.getName().equals(itemName)) {
+                nameList.add(item);
+            }
+        }
+        namePriceMap.put(itemName, getPriceMap(nameList));
+
+        return namePriceMap;
+    }
+
+    public static HashMap<Double, Integer> getPriceMap(ArrayList<Item> items) {
+
+        HashMap<Double, Integer> map = new HashMap<>();
+
+        for (Item item : items) {
+            if (map.containsKey(item.getPrice())) {
+                Integer newItemCount = map.get(item.getPrice());
+                newItemCount++;
+                map.put(item.getPrice(), newItemCount);
+            } else {
+                map.put(item.getPrice(), 1);
+            }
+        }
+        return map;
+    }
+
+    public static HashMap<String, Integer> getNameMap(ArrayList<Item> items) {
+
+        HashMap<String, Integer> map = new HashMap<>();
+
+        for (Item item : items) {
+            if (map.containsKey(item.getName())) {
+                Integer newItemCount = map.get(item.getName());
+                newItemCount++;
+                map.put(item.getName(), newItemCount);
+            } else {
+                map.put(item.getName(), 1);
+            }
+        }
+        return map;
     }
 }
+