Get MakerItemCreateEntry from new info provider

src/main/java/client/processor/action/MakerProcessor.java

@@ -154,7 +154,11 @@ public class MakerProcessor {
                         }
                     }
 
-                    recipe = MakerItemFactory.getItemCreateEntry(toCreate, stimulantid, reagentids);
+                    Optional<MakerItemCreateEntry> createEntry = infoProvider.getMakerItemEntry(toCreate);
+                    if (createEntry.isEmpty()) {
+                        return;
+                    }
+                    recipe = MakerItemFactory.finalizeItemCreateEntry(createEntry.get(), toCreate, stimulantid, reagentids);
                 }
 
                 short createStatus = getCreateStatus(c, recipe);

src/main/java/database/maker/MakerInfoProvider.java

@@ -4,6 +4,7 @@ import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import constants.id.ItemId;
 import net.jcip.annotations.ThreadSafe;
+import server.MakerItemFactory.MakerItemCreateEntry;
 
 import java.util.List;
 import java.util.Optional;
@@ -60,4 +61,21 @@ public class MakerInfoProvider {
         fee *= 1000;
         return fee;
     }
+
+    public Optional<MakerItemCreateEntry> getMakerItemEntry(int itemId) {
+        Optional<MakerRecipe> optionalRecipe = getMakerRecipe(itemId);
+        if (optionalRecipe.isEmpty()) {
+            return Optional.empty();
+        }
+
+        final MakerRecipe recipe = optionalRecipe.get();
+        final MakerItemCreateEntry makerEntry = new MakerItemCreateEntry(recipe.mesoCost(), recipe.requiredLevel(),
+                recipe.requiredMakerLevel());
+        makerEntry.addGainItem(itemId, recipe.quantity());
+
+        final List<MakerIngredient> ingredients = getIngredients(itemId);
+        ingredients.forEach(i -> makerEntry.addReqItem(i.itemId(), i.count()));
+
+        return Optional.of(makerEntry);
+    }
 }

src/main/java/server/ItemInformationProvider.java

@@ -37,7 +37,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import provider.*;
 import provider.wz.WZFiles;
-import server.MakerItemFactory.MakerItemCreateEntry;
 import server.life.LifeFactory;
 import server.life.MonsterInformationProvider;
 import tools.DatabaseConnection;
@@ -112,8 +111,6 @@ public class ItemInformationProvider {
     protected Map<Integer, String> equipmentSlotCache = new HashMap<>();
     protected Map<Integer, Boolean> noCancelMouseCache = new HashMap<>();
     protected Map<Integer, Integer> mobCrystalMakerCache = new HashMap<>();
-    protected Map<Integer, Pair<String, Integer>> statUpgradeMakerCache = new HashMap<>();
-    protected Map<Integer, MakerItemFactory.MakerItemCreateEntry> makerItemCache = new HashMap<>();
     protected Map<Integer, Map<String, Integer>> skillUpgradeCache = new HashMap<>();
     protected Map<Integer, Data> skillUpgradeInfoCache = new HashMap<>();
     protected Map<Integer, Pair<Integer, Set<Integer>>> cashPetFoodCache = new HashMap<>();
@@ -2017,51 +2014,6 @@ public class ItemInformationProvider {
         return -1;
     }
 
-    public MakerItemCreateEntry getMakerItemEntry(int toCreate) {
-        MakerItemCreateEntry makerEntry;
-
-        if ((makerEntry = makerItemCache.get(toCreate)) != null) {
-            return new MakerItemCreateEntry(makerEntry);
-        } else {
-            try (Connection con = DatabaseConnection.getConnection()) {
-                int reqLevel = -1;
-                int reqMakerLevel = -1;
-                int cost = -1;
-                int toGive = -1;
-                try (PreparedStatement ps = con.prepareStatement("SELECT req_level, req_maker_level, req_meso, quantity FROM makercreatedata WHERE itemid = ?")) {
-                    ps.setInt(1, toCreate);
-                    try (ResultSet rs = ps.executeQuery()) {
-                        if (rs.next()) {
-                            reqLevel = rs.getInt("req_level");
-                            reqMakerLevel = rs.getInt("req_maker_level");
-                            cost = rs.getInt("req_meso");
-                            toGive = rs.getInt("quantity");
-                        }
-                    }
-                }
-
-                makerEntry = new MakerItemCreateEntry(cost, reqLevel, reqMakerLevel);
-                makerEntry.addGainItem(toCreate, toGive);
-
-                try (PreparedStatement ps = con.prepareStatement("SELECT req_item, count FROM makerrecipedata WHERE itemid = ?")) {
-                    ps.setInt(1, toCreate);
-
-                    try (ResultSet rs = ps.executeQuery()) {
-                        while (rs.next()) {
-                            makerEntry.addReqItem(rs.getInt("req_item"), rs.getInt("count"));
-                        }
-                    }
-                }
-                makerItemCache.put(toCreate, new MakerItemCreateEntry(makerEntry));
-            } catch (SQLException sqle) {
-                sqle.printStackTrace();
-                makerEntry = null;
-            }
-        }
-
-        return makerEntry;
-    }
-
     public int getMakerCrystalFromEquip(Integer equipId) {
         try {
             return getCrystalForLevel(getEquipLevelReq(equipId));

src/main/java/server/MakerItemFactory.java

@@ -37,8 +37,7 @@ import java.util.Map.Entry;
 public class MakerItemFactory {
     private static final ItemInformationProvider ii = ItemInformationProvider.getInstance();
 
-    public static MakerItemCreateEntry getItemCreateEntry(int toCreate, int stimulantid, Map<Integer, Short> reagentids) {
+    public static MakerItemCreateEntry finalizeItemCreateEntry(MakerItemCreateEntry makerEntry, int toCreate, int stimulantid, Map<Integer, Short> reagentids) {
-        MakerItemCreateEntry makerEntry = ii.getMakerItemEntry(toCreate);
         if (makerEntry.isInvalid()) {
             return makerEntry;
         }
@@ -156,16 +155,6 @@ public class MakerItemFactory {
             this.reqMakerLevel = reqMakerLevel;
         }
 
-        public MakerItemCreateEntry(MakerItemCreateEntry mi) {
-            this.cost = mi.cost;
-            this.reqLevel = mi.reqLevel;
-            this.reqMakerLevel = mi.reqMakerLevel;
-
-            reqItems.addAll(mi.reqItems);
-
-            gainItems.addAll(mi.gainItems);
-        }
-
         public List<Pair<Integer, Integer>> getReqItems() {
             return reqItems;
         }
@@ -194,11 +183,11 @@ public class MakerItemFactory {
             return (int) this.cost;
         }
 
-        protected void addReqItem(int itemId, int amount) {
+        public void addReqItem(int itemId, int amount) {
             reqItems.add(new Pair<>(itemId, amount));
         }
 
-        protected void addGainItem(int itemId, int amount) {
+        public void addGainItem(int itemId, int amount) {
             gainItems.add(new Pair<>(itemId, amount));
         }
 

src/test/java/database/maker/MakerInfoProviderTest.java

@@ -4,8 +4,11 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import server.MakerItemFactory;
 import testutil.AnyValues;
+import tools.Pair;
 
+import java.util.List;
 import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -75,7 +78,7 @@ class MakerInfoProviderTest {
 
     @Test
     void getRecipeFromDb_notFound() {
-        when(makerDao.getRecipe(anyInt())).thenReturn(Optional.empty());
+        givenNoRecipe();
 
         Optional<MakerRecipe> recipe = makerInfoProvider.getMakerRecipe(AnyValues.integer());
 
@@ -116,10 +119,48 @@ class MakerInfoProviderTest {
 
     @Test
     void getStimulant_noRecipe() {
-        when(makerDao.getRecipe(anyInt())).thenReturn(Optional.empty());
+        givenNoRecipe();
 
         Optional<Integer> stimulant = makerInfoProvider.getStimulant(AnyValues.integer());
 
         assertTrue(stimulant.isEmpty());
     }
+
+    @Test
+    void getMakerItemCreateEntry_noRecipe() {
+        givenNoRecipe();
+
+        Optional<MakerItemFactory.MakerItemCreateEntry> createEntry = makerInfoProvider.getMakerItemEntry(345093);
+
+        assertTrue(createEntry.isEmpty());
+    }
+
+    @Test
+    void getMakerItemCreateEntry() {
+        final int itemId = 458945;
+        MakerRecipe recipe = createRecipe(itemId);
+        when(makerDao.getRecipe(anyInt())).thenReturn(Optional.of(recipe));
+        MakerIngredient ingredient = new MakerIngredient(1002003, (short) 5);
+        when(makerDao.getIngredients(anyInt())).thenReturn(List.of(ingredient));
+
+        Optional<MakerItemFactory.MakerItemCreateEntry> optionalCreateEntry = makerInfoProvider.getMakerItemEntry(itemId);
+
+        assertTrue(optionalCreateEntry.isPresent());
+        MakerItemFactory.MakerItemCreateEntry createEntry = optionalCreateEntry.get();
+        assertEquals(recipe.mesoCost(), createEntry.getCost());
+        assertEquals(recipe.requiredLevel(), createEntry.getReqLevel());
+        assertEquals(recipe.requiredMakerLevel(), createEntry.getReqSkillLevel());
+        assertEquals(1, createEntry.getReqItems().size());
+        Pair<Integer, Integer> ingredientPair = createEntry.getReqItems().get(0);
+        assertEquals(ingredient.itemId(), ingredientPair.left);
+        assertEquals(ingredient.count(), ingredientPair.right);
+        assertEquals(1, createEntry.getGainItems().size());
+        Pair<Integer, Integer> resultPair = createEntry.getGainItems().get(0);
+        assertEquals(itemId, resultPair.left);
+        assertEquals(recipe.quantity(), resultPair.right);
+    }
+
+    private void givenNoRecipe() {
+        when(makerDao.getRecipe(anyInt())).thenReturn(Optional.empty());
+    }
 }