Wrote tests for the completed task

src/main/java/core/basesyntax/data/dao/FileReader.java

@@ -0,0 +1,7 @@
+package core.basesyntax.data.dao;
+
+import java.util.List;
+
+public interface FileReader {
+    List<String> readFile(String fileName);
+}

src/main/java/core/basesyntax/data/dao/FileReaderImpl.java

@@ -0,0 +1,21 @@
+package core.basesyntax.data.dao;
+
+import core.basesyntax.data.exeption.FileException;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+public class FileReaderImpl implements FileReader {
+
+    @Override
+    public List<String> readFile(String filePath) {
+        List<String> reportList;
+        try {
+            reportList = Files.readAllLines(Path.of(filePath));
+        } catch (IOException e) {
+            throw new FileException("Can't read data from file: " + filePath, e);
+        }
+        return reportList;
+    }
+}

src/main/java/core/basesyntax/data/dao/FileWriter.java

@@ -0,0 +1,7 @@
+package core.basesyntax.data.dao;
+
+import java.util.List;
+
+public interface FileWriter {
+    List<String> writeFile(String filePath, String report);
+}

src/main/java/core/basesyntax/data/dao/FileWriterImpl.java

@@ -0,0 +1,19 @@
+package core.basesyntax.data.dao;
+
+import core.basesyntax.data.exeption.FileException;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+public class FileWriterImpl implements FileWriter {
+    @Override
+    public List<String> writeFile(String filePath, String report) {
+        try {
+            Files.writeString(Path.of(filePath), report);
+        } catch (IOException e) {
+            throw new FileException("Can't write data to file: " + filePath, e);
+        }
+        return null;
+    }
+}

src/main/java/core/basesyntax/data/db/Storage.java

@@ -0,0 +1,8 @@
+package core.basesyntax.data.db;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Storage {
+    public static final Map<String, Integer> fruitsStorage = new HashMap<>();
+}

src/main/java/core/basesyntax/data/exeption/FileException.java

@@ -0,0 +1,7 @@
+package core.basesyntax.data.exeption;
+
+public class FileException extends RuntimeException {
+    public FileException(String message, Throwable cause) {
+        super(message,cause);
+    }
+}

src/main/java/core/basesyntax/data/exeption/InvalidArraySplitLength.java

@@ -0,0 +1,7 @@
+package core.basesyntax.data.exeption;
+
+public class InvalidArraySplitLength extends IllegalArgumentException {
+    public InvalidArraySplitLength(String message) {
+        super(message);
+    }
+}

src/main/java/core/basesyntax/data/exeption/OperationException.java

@@ -0,0 +1,7 @@
+package core.basesyntax.data.exeption;
+
+public class OperationException extends RuntimeException {
+    public OperationException(String message) {
+        super(message);
+    }
+}

src/main/java/core/basesyntax/data/model/FruitTransaction.java

@@ -0,0 +1,37 @@
+package core.basesyntax.data.model;
+
+public class FruitTransaction {
+    private OperationType operation;
+    private String fruit;
+    private int quantity;
+
+    public FruitTransaction(OperationType operation, String fruit, int quantity) {
+        this.operation = operation;
+        this.fruit = fruit;
+        this.quantity = quantity;
+    }
+
+    public OperationType getOperation() {
+        return operation;
+    }
+
+    public void setOperation(OperationType operation) {
+        this.operation = operation;
+    }
+
+    public String getFruit() {
+        return fruit;
+    }
+
+    public void setFruit(String fruit) {
+        this.fruit = fruit;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+
+    public void setQuantity(int quantity) {
+        this.quantity = quantity;
+    }
+}

src/main/java/core/basesyntax/data/model/OperationType.java

@@ -0,0 +1,26 @@
+package core.basesyntax.data.model;
+
+public enum OperationType {
+    BALANCE("b"),
+    SUPPLY("s"),
+    PURCHASE("p"),
+    RETURN("r");
+    private String code;
+
+    OperationType(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public static OperationType fromCode(String code) {
+        for (OperationType operation : OperationType.values()) {
+            if (operation.getCode().equals(code)) {
+                return operation;
+            }
+        }
+        throw new IllegalArgumentException("No enum constant for code: " + code);
+    }
+}

src/main/java/core/basesyntax/data/servise/DataConverter.java

@@ -0,0 +1,8 @@
+package core.basesyntax.data.servise;
+
+import core.basesyntax.data.model.FruitTransaction;
+import java.util.List;
+
+public interface DataConverter {
+    List<FruitTransaction> convertToOperation(List<String> reportList);
+}

src/main/java/core/basesyntax/data/servise/ReportGenerator.java

@@ -0,0 +1,5 @@
+package core.basesyntax.data.servise;
+
+public interface ReportGenerator {
+    String getReport();
+}

src/main/java/core/basesyntax/data/servise/ShopService.java

@@ -0,0 +1,8 @@
+package core.basesyntax.data.servise;
+
+import core.basesyntax.data.model.FruitTransaction;
+import java.util.List;
+
+public interface ShopService {
+    void process(List<FruitTransaction> operations);
+}

src/main/java/core/basesyntax/data/servise/StrategyOperationService.java

@@ -0,0 +1,8 @@
+package core.basesyntax.data.servise;
+
+import core.basesyntax.data.model.OperationType;
+import core.basesyntax.data.strategy.OperationHandler;
+
+public interface StrategyOperationService {
+    OperationHandler get(OperationType operationType);
+}

src/main/java/core/basesyntax/data/servise/ipl/DataConverterImpl.java

@@ -0,0 +1,30 @@
+package core.basesyntax.data.servise.ipl;
+
+import core.basesyntax.data.model.FruitTransaction;
+import core.basesyntax.data.model.OperationType;
+import core.basesyntax.data.servise.DataConverter;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DataConverterImpl implements DataConverter {
+    private static final int LIST_START = 1;
+    private static final int OPERATION_INDEX = 0;
+    private static final int FRUIT_INDEX = 1;
+    private static final int QUANTITY_INDEX = 2;
+    private static final String COMMA = ",";
+
+    @Override
+    public List<FruitTransaction> convertToOperation(List<String> reportList) {
+        List<FruitTransaction> shopOperationList = new ArrayList<>();
+        for (String line : reportList.subList(LIST_START, reportList.size())) {
+            String[] parts = line.split(COMMA);
+            String codeOperation = parts[OPERATION_INDEX];
+            String fruit = parts[FRUIT_INDEX];
+            int quantity = Integer.parseInt(parts[QUANTITY_INDEX]);
+            shopOperationList.add(
+                    new FruitTransaction(OperationType. fromCode(codeOperation),
+                            fruit, quantity));
+        }
+        return shopOperationList;
+    }
+}

src/main/java/core/basesyntax/data/servise/ipl/ReportGeneratorImpl.java

@@ -0,0 +1,23 @@
+package core.basesyntax.data.servise.ipl;
+
+import core.basesyntax.data.db.Storage;
+import core.basesyntax.data.servise.ReportGenerator;
+import java.util.Map;
+
+public class ReportGeneratorImpl implements ReportGenerator {
+    private static final String LINE_SEPARATOR = System.lineSeparator();
+    private static final String COMMA = ",";
+    private static final String HEADER = "fruit,quantity";
+
+    @Override
+    public String getReport() {
+        StringBuilder stringBuilder = new StringBuilder(HEADER + LINE_SEPARATOR);
+        for (Map.Entry<String, Integer> entry : Storage.fruitsStorage.entrySet()) {
+            stringBuilder.append(entry.getKey())
+                    .append(COMMA)
+                    .append(entry.getValue())
+                    .append(LINE_SEPARATOR);
+        }
+        return stringBuilder.toString();
+    }
+}

src/main/java/core/basesyntax/data/servise/ipl/ShopServiceImpl.java

@@ -0,0 +1,21 @@
+package core.basesyntax.data.servise.ipl;
+
+import core.basesyntax.data.model.FruitTransaction;
+import core.basesyntax.data.servise.ShopService;
+import core.basesyntax.data.servise.StrategyOperationService;
+import java.util.List;
+
+public class ShopServiceImpl implements ShopService {
+    private final StrategyOperationService strategyOperationService;
+
+    public ShopServiceImpl(StrategyOperationService strategyOperationService) {
+        this.strategyOperationService = strategyOperationService;
+    }
+
+    @Override
+    public void process(List<FruitTransaction> operations) {
+        for (FruitTransaction operation : operations) {
+            strategyOperationService.get(operation.getOperation()).handle(operation);
+        }
+    }
+}

src/main/java/core/basesyntax/data/servise/ipl/StrategyOperationServiceImpl.java

@@ -0,0 +1,24 @@
+package core.basesyntax.data.servise.ipl;
+
+import core.basesyntax.data.exeption.OperationException;
+import core.basesyntax.data.model.OperationType;
+import core.basesyntax.data.servise.StrategyOperationService;
+import core.basesyntax.data.strategy.OperationHandler;
+import java.util.Map;
+
+public class StrategyOperationServiceImpl implements StrategyOperationService {
+    private Map<OperationType, OperationHandler> operationHandlerMap;
+
+    public StrategyOperationServiceImpl(Map<OperationType, OperationHandler> operationHandlerMap) {
+        this.operationHandlerMap = operationHandlerMap;
+    }
+
+    @Override
+    public OperationHandler get(OperationType operationType) {
+        OperationHandler handler = operationHandlerMap.get(operationType);
+        if (handler != null) {
+            return handler;
+        }
+        throw new OperationException("Operation type is not correct: " + operationType);
+    }
+}

src/main/java/core/basesyntax/data/strategy/BalanceOperationHandler.java

@@ -0,0 +1,19 @@
+package core.basesyntax.data.strategy;
+
+import core.basesyntax.data.db.Storage;
+import core.basesyntax.data.exeption.OperationException;
+import core.basesyntax.data.model.FruitTransaction;
+
+public class BalanceOperationHandler implements OperationHandler {
+
+    @Override
+    public void handle(FruitTransaction operation) {
+        int quantity = operation.getQuantity();
+        if (quantity < 0) {
+            throw new OperationException(
+                    "Operation is not correct, quantity can't be negative. Quantity: "
+                            + operation.getQuantity());
+        }
+        Storage.fruitsStorage.put(operation.getFruit(), operation.getQuantity());
+    }
+}

src/main/java/core/basesyntax/data/strategy/OperationHandler.java

@@ -0,0 +1,8 @@
+package core.basesyntax.data.strategy;
+
+import core.basesyntax.data.model.FruitTransaction;
+
+public interface OperationHandler {
+
+    void handle(FruitTransaction operation);
+}

src/main/java/core/basesyntax/data/strategy/PurchaseOperationHandler.java

@@ -0,0 +1,29 @@
+package core.basesyntax.data.strategy;
+
+import core.basesyntax.data.db.Storage;
+import core.basesyntax.data.exeption.OperationException;
+import core.basesyntax.data.model.FruitTransaction;
+
+public class PurchaseOperationHandler implements OperationHandler {
+
+    @Override
+    public void handle(FruitTransaction operation) {
+
+        String fruit = operation.getFruit();
+        if (!Storage.fruitsStorage.containsKey(fruit)) {
+            throw new OperationException("Operation is not correct, fruit doesn't exist: " + fruit);
+        }
+        int quantity = Storage.fruitsStorage.get(fruit);
+        int quantityToBuy = operation.getQuantity();
+        if (quantityToBuy < 0) {
+            throw new OperationException(
+                    "Operation is not correct, quantity can't be negative. Quantity: "
+                            + quantityToBuy);
+        }
+        if (quantity < quantityToBuy) {
+            throw new OperationException("Operation is impossible, not enough quantity of: "
+                    + fruit);
+        }
+        Storage.fruitsStorage.put(fruit, quantity - quantityToBuy);
+    }
+}

src/main/java/core/basesyntax/data/strategy/ReturnOperationHandler.java

@@ -0,0 +1,25 @@
+package core.basesyntax.data.strategy;
+
+import core.basesyntax.data.db.Storage;
+import core.basesyntax.data.exeption.OperationException;
+import core.basesyntax.data.model.FruitTransaction;
+
+public class ReturnOperationHandler implements OperationHandler {
+
+    @Override
+    public void handle(FruitTransaction operation) {
+        String fruit = operation.getFruit();
+        if (!Storage.fruitsStorage.containsKey(fruit)) {
+            throw new OperationException("Operation is not correct, fruit doesn't exist: " + fruit);
+        }
+        int quantity = Storage.fruitsStorage.get(fruit);
+        int returnedQuantity = operation.getQuantity();
+        if (returnedQuantity < 0) {
+            throw new OperationException(
+                    "Operation is not correct, quantity can't be negative. Quantity: "
+                            + returnedQuantity);
+        }
+        Storage.fruitsStorage.put(fruit, quantity + returnedQuantity);
+
+    }
+}