Apply formatter, migrate to java UUID instead of string for processId, remove...

Apply formatter, migrate to java UUID instead of string for processId, remove @Autowired annotations

account-query/src/main/java/cz/muni/pa165/banking/application/controller/BalanceController.java

@@ -5,7 +5,6 @@ import cz.muni.pa165.banking.account.query.SystemServiceApi;
 import cz.muni.pa165.banking.account.query.dto.Transaction;
 import cz.muni.pa165.banking.account.query.dto.TransactionType;
 import cz.muni.pa165.banking.application.facade.BalanceFacade;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.RestController;
@@ -13,14 +12,16 @@ import org.springframework.web.bind.annotation.RestController;
 import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.List;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 @RestController
 public class BalanceController implements CustomerServiceApi, SystemServiceApi {
+
     private final BalanceFacade balanceFacade;
-    @Autowired
+
     public BalanceController(BalanceFacade balanceFacade) {
         this.balanceFacade = balanceFacade;
     }
@@ -32,14 +33,13 @@ public class BalanceController implements CustomerServiceApi, SystemServiceApi {
     }
 
     @Override
-    public ResponseEntity<List<Transaction>> getTransactions(String id, LocalDate beginning, LocalDate end,
-                                                             BigDecimal minAmount, BigDecimal maxAmount, TransactionType type) {
+    public ResponseEntity<List<Transaction>> getTransactions(String id, LocalDate beginning, LocalDate end, BigDecimal minAmount, BigDecimal maxAmount, TransactionType type) {
         List<Transaction> toReturn = balanceFacade.getTransactions(id, beginning, end, minAmount, maxAmount, type);
         return ResponseEntity.ok(toReturn);
     }
 
     @Override
-    public ResponseEntity<Void> addTransactionToBalance(String id, BigDecimal amount, String processId, TransactionType type) {
+    public ResponseEntity<Void> addTransactionToBalance(String id, BigDecimal amount, UUID processId, TransactionType type) {
         balanceFacade.addToBalance(id, processId, amount, type);
         return ResponseEntity.ok().build();
     }
@@ -47,6 +47,6 @@ public class BalanceController implements CustomerServiceApi, SystemServiceApi {
     @Override
     public ResponseEntity<Void> createBalance(String id) {
         balanceFacade.createNewBalance(id);
-        return new ResponseEntity<Void>(HttpStatus.CREATED);
+        return new ResponseEntity<>(HttpStatus.CREATED);
     }
 }

account-query/src/main/java/cz/muni/pa165/banking/application/controller/BalanceControllerEmployee.java

@@ -5,7 +5,6 @@ import cz.muni.pa165.banking.account.query.dto.Transaction;
 import cz.muni.pa165.banking.account.query.dto.TransactionType;
 import cz.muni.pa165.banking.account.query.dto.TransactionsReport;
 import cz.muni.pa165.banking.application.facade.BalanceFacade;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -18,11 +17,13 @@ import java.util.List;
  */
 @RestController
 public class BalanceControllerEmployee implements EmployeeServiceApi {
+
     private final BalanceFacade balanceFacade;
-    @Autowired
+
     public BalanceControllerEmployee(BalanceFacade balanceFacade) {
         this.balanceFacade = balanceFacade;
     }
+
     @Override
     public ResponseEntity<TransactionsReport> createReport(String id, LocalDate beginning, LocalDate end) {
         TransactionsReport result = balanceFacade.getReport(id, beginning, end);

account-query/src/main/java/cz/muni/pa165/banking/application/exception/RestApiExceptionHandler.java

 package cz.muni.pa165.banking.application.exception;
 
-import cz.muni.pa165.banking.application.exception.NotFoundAccountException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.MethodArgumentNotValidException;

account-query/src/main/java/cz/muni/pa165/banking/application/facade/BalanceFacade.java

@@ -3,11 +3,9 @@ package cz.muni.pa165.banking.application.facade;
 import cz.muni.pa165.banking.account.query.dto.Transaction;
 import cz.muni.pa165.banking.account.query.dto.TransactionType;
 import cz.muni.pa165.banking.account.query.dto.TransactionsReport;
-import cz.muni.pa165.banking.application.mapper.BalanceMapper;
 import cz.muni.pa165.banking.application.exception.NotFoundAccountException;
+import cz.muni.pa165.banking.application.mapper.BalanceMapper;
 import cz.muni.pa165.banking.domain.balance.service.BalanceService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
@@ -16,16 +14,17 @@ import java.time.LocalTime;
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.util.List;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 @Service
 public class BalanceFacade {
+
     private final BalanceService balanceService;
     private final BalanceMapper balanceMapper;
 
-    @Autowired
     public BalanceFacade(BalanceService balanceService, BalanceMapper balanceMapper) {
         this.balanceService = balanceService;
         this.balanceMapper = balanceMapper;
@@ -35,7 +34,7 @@ public class BalanceFacade {
         balanceService.addNewBalance(id);
     }
 
-    public void addToBalance(String id, String processId, BigDecimal value, TransactionType type) {
+    public void addToBalance(String id, UUID processId, BigDecimal value, TransactionType type) {
         balanceService.addToBalance(id, value, processId, balanceMapper.mapTypeOut(type));
     }
 
@@ -46,13 +45,10 @@ public class BalanceFacade {
     public List<Transaction> getTransactions(String id, LocalDate beginning, LocalDate end, BigDecimal minAmount,
                                              BigDecimal maxAmount, TransactionType type) {
         List<cz.muni.pa165.banking.domain.transaction.Transaction> toReturn;
-        if(type == null){
-            toReturn = balanceService.getTransactions(id, OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC),
-                            OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC), minAmount, maxAmount, null);
-        }
-        else {
-            toReturn = balanceService.getTransactions(id, OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC),
-                            OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC),
+        if (type == null) {
+            toReturn = balanceService.getTransactions(id, OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC), OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC), minAmount, maxAmount, null);
+        } else {
+            toReturn = balanceService.getTransactions(id, OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC), OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC),
                     minAmount, maxAmount, balanceMapper.mapTypeOut(type));
         }
         return toReturn.stream().map(balanceMapper::mapTransactionIn).toList();
@@ -66,15 +62,14 @@ public class BalanceFacade {
 
     public List<Transaction> getAllTransactions(LocalDate beginning, LocalDate end, BigDecimal minAmount,
                                                 BigDecimal maxAmount, TransactionType type) {
-        if(type == null){
+        if (type == null) {
             List<cz.muni.pa165.banking.domain.transaction.Transaction> toReturn =
                     balanceService.getAllTransactions(OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC),
                             OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC), minAmount, maxAmount, null);
             return toReturn.stream().map(balanceMapper::mapTransactionIn).toList();
         }
         List<cz.muni.pa165.banking.domain.transaction.Transaction> toReturn =
-                balanceService.getAllTransactions(OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC),
-                OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC), minAmount, maxAmount,
+                balanceService.getAllTransactions(OffsetDateTime.of(beginning, LocalTime.MIDNIGHT, ZoneOffset.UTC), OffsetDateTime.of(end, LocalTime.MIDNIGHT, ZoneOffset.UTC), minAmount, maxAmount,
                         balanceMapper.mapTypeOut(type));
         return toReturn.stream().map(balanceMapper::mapTransactionIn).toList();
     }

account-query/src/main/java/cz/muni/pa165/banking/application/repository/BalancesRepositoryImpl.java

@@ -2,22 +2,20 @@ package cz.muni.pa165.banking.application.repository;
 
 import cz.muni.pa165.banking.domain.balance.Balance;
 import cz.muni.pa165.banking.domain.balance.repository.BalancesRepository;
-import cz.muni.pa165.banking.domain.report.StatisticalReport;
-import cz.muni.pa165.banking.domain.transaction.Transaction;
-import cz.muni.pa165.banking.domain.transaction.TransactionType;
 import org.springframework.stereotype.Repository;
 
-import java.math.BigDecimal;
-import java.time.OffsetDateTime;
-import java.util.*;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 
 /**
  * @author Martin Mojzis
  */
 @Repository
 public class BalancesRepositoryImpl implements BalancesRepository {
-    //private final Map<Integer, Balance> allBalances = new HashMap<>();
-    private Map<String, Balance> mockData = new HashMap<>();
+
+    private final Map<String, Balance> mockData = new HashMap<>();
 
     public BalancesRepositoryImpl() {
         mockData.put("id1", new Balance("id1"));

account-query/src/main/java/cz/muni/pa165/banking/application/service/BalanceServiceImpl.java

@@ -7,27 +7,24 @@ import cz.muni.pa165.banking.domain.balance.service.BalanceService;
 import cz.muni.pa165.banking.domain.report.StatisticalReport;
 import cz.muni.pa165.banking.domain.transaction.Transaction;
 import cz.muni.pa165.banking.domain.transaction.TransactionType;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
-import java.time.LocalDate;
 import java.time.OffsetDateTime;
-import java.util.Date;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Optional;
+import java.util.Objects;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 @Service
 public class BalanceServiceImpl implements BalanceService {
+
     private final BalancesRepository balanceRepository;
 
-    @Autowired
-    public BalanceServiceImpl(BalancesRepository balanceRepository){
+    public BalanceServiceImpl(BalancesRepository balanceRepository) {
         this.balanceRepository = balanceRepository;
     }
 
@@ -38,7 +35,7 @@ public class BalanceServiceImpl implements BalanceService {
 
     @Override
     public BigDecimal getBalance(String id) throws NotFoundAccountException {
-        Balance balance = this.findById(id);
+        Balance balance = findById(id);
         return balance.getAmount();
     }
 
@@ -46,7 +43,7 @@ public class BalanceServiceImpl implements BalanceService {
     public List<Transaction> getTransactions(String id, OffsetDateTime from, OffsetDateTime to, BigDecimal minAmount,
                                              BigDecimal maxAmount, TransactionType type)
             throws NotFoundAccountException {
-        Balance balance = this.findById(id);
+        Balance balance = findById(id);
         if (minAmount == null && maxAmount == null && type == null)
             return balance.getData(from, to, BigDecimal.valueOf(Integer.MIN_VALUE),
                     BigDecimal.valueOf(Integer.MAX_VALUE));
@@ -59,20 +56,20 @@ public class BalanceServiceImpl implements BalanceService {
             return balance.getData(from, to, BigDecimal.valueOf(Integer.MIN_VALUE), maxAmount);
         if (maxAmount == null)
             return balance.getData(from, to, minAmount, BigDecimal.valueOf(Integer.MAX_VALUE), type);
-        if (minAmount == null) return balance.getData(from, to, BigDecimal.ZERO, maxAmount, type);
-        return balance.getData(from, to, minAmount, maxAmount, type);
+
+        return balance.getData(from, to, Objects.requireNonNullElse(minAmount, BigDecimal.ZERO), maxAmount, type);
     }
 
     @Override
-    public void addToBalance(String id, BigDecimal amount, String processID, TransactionType type)
+    public void addToBalance(String id, BigDecimal amount, UUID processID, TransactionType type)
             throws NotFoundAccountException {
-        Balance balance = this.findById(id);
+        Balance balance = findById(id);
         balance.addTransaction(amount, type, processID);
     }
 
     @Override
-    public StatisticalReport getReport(String id,  OffsetDateTime beginning,  OffsetDateTime end) {
-        Balance balance = this.findById(id);
+    public StatisticalReport getReport(String id, OffsetDateTime beginning, OffsetDateTime end) {
+        Balance balance = findById(id);
         return balance.getReport(beginning, end);
     }
 
@@ -80,13 +77,12 @@ public class BalanceServiceImpl implements BalanceService {
     public List<Transaction> getAllTransactions(OffsetDateTime from, OffsetDateTime to, BigDecimal minAmount,
                                                 BigDecimal maxAmount, TransactionType transactionType) {
         List<Transaction> result = new LinkedList<>();
-        for (String id: balanceRepository.getAllIds()) {
-            result.addAll(getTransactions(id, from,  to, minAmount, maxAmount, transactionType));
+        for (String id : balanceRepository.getAllIds()) {
+            result.addAll(getTransactions(id, from, to, minAmount, maxAmount, transactionType));
         }
         return result;
     }
 
-    @Transactional(readOnly = true)
     public Balance findById(String id) throws NotFoundAccountException {
         return balanceRepository.findById(id)
                 .orElseThrow(() -> new NotFoundAccountException("Balance  of person with id: " + id + " was not found."));

account-query/src/main/java/cz/muni/pa165/banking/domain/balance/Balance.java

@@ -5,17 +5,21 @@ import cz.muni.pa165.banking.domain.transaction.Transaction;
 import cz.muni.pa165.banking.domain.transaction.TransactionType;
 
 import java.math.BigDecimal;
-import java.time.*;
+import java.time.OffsetDateTime;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 public class Balance {
+
     private final String accountId;
+
     private BigDecimal amount;
+
     private final List<Transaction> transactionList;
 
     public Balance(String userId) {
@@ -24,7 +28,7 @@ public class Balance {
         this.accountId = userId;
     }
 
-    public void addTransaction(BigDecimal amount, TransactionType type, String processId) {
+    public void addTransaction(BigDecimal amount, TransactionType type, UUID processId) {
         transactionList.add(new Transaction(type, amount,
                 OffsetDateTime.now(), processId));
         this.amount = this.amount.add(amount);
@@ -38,7 +42,7 @@ public class Balance {
         return transactionList;
     }
 
-    public Transaction getTransaction(String pid) throws RuntimeException {
+    public Transaction getTransaction(UUID pid) throws RuntimeException {
         List<Transaction> result = transactionList.stream().filter(a -> Objects.equals(a.getProcessId(), pid)).toList();
         if (result.isEmpty()) {
             throw new RuntimeException("list has no tranaction with this id");
@@ -46,7 +50,7 @@ public class Balance {
         return result.get(0);
     }
 
-    public boolean transactionExists(String pid) {
+    public boolean transactionExists(UUID pid) {
         List<Transaction> result = transactionList.stream().filter(a -> Objects.equals(a.getProcessId(), pid)).toList();
         return !result.isEmpty();
     }

account-query/src/main/java/cz/muni/pa165/banking/domain/balance/repository/BalancesRepository.java

 package cz.muni.pa165.banking.domain.balance.repository;
 
 import cz.muni.pa165.banking.domain.balance.Balance;
-import cz.muni.pa165.banking.domain.report.StatisticalReport;
-import cz.muni.pa165.banking.domain.transaction.Transaction;
-import cz.muni.pa165.banking.domain.transaction.TransactionType;
 
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.time.OffsetDateTime;
-import java.util.Date;
 import java.util.List;
 import java.util.Optional;
 
@@ -18,6 +11,7 @@ import java.util.Optional;
 public interface BalancesRepository {
 
     Optional<Balance> findById(String id);
+
     void addBalance(String id);
 
     List<String> getAllIds();

account-query/src/main/java/cz/muni/pa165/banking/domain/balance/service/BalanceService.java

@@ -6,15 +6,15 @@ import cz.muni.pa165.banking.domain.transaction.Transaction;
 import cz.muni.pa165.banking.domain.transaction.TransactionType;
 
 import java.math.BigDecimal;
-import java.time.LocalDate;
 import java.time.OffsetDateTime;
-import java.util.Date;
 import java.util.List;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 public interface BalanceService {
+
     void addNewBalance(String id) throws NotFoundAccountException;
 
     BigDecimal getBalance(String id) throws NotFoundAccountException;
@@ -22,7 +22,7 @@ public interface BalanceService {
     List<Transaction> getTransactions(String id, OffsetDateTime from, OffsetDateTime to, BigDecimal minAmount,
                                       BigDecimal maxAmount, TransactionType type) throws NotFoundAccountException;
 
-    void addToBalance(String id, BigDecimal amount, String processID, TransactionType type) throws NotFoundAccountException;
+    void addToBalance(String id, BigDecimal amount, UUID processID, TransactionType type) throws NotFoundAccountException;
 
     StatisticalReport getReport(String id, OffsetDateTime beginning, OffsetDateTime end);
 

account-query/src/main/java/cz/muni/pa165/banking/domain/report/StatisticalReport.java

@@ -4,25 +4,29 @@ import cz.muni.pa165.banking.domain.transaction.Transaction;
 import cz.muni.pa165.banking.domain.transaction.TransactionType;
 
 import java.math.BigDecimal;
-import java.util.Date;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * @author Martin Mojzis
  */
 public class StatisticalReport {
     //report total and average (per account) transactions (deposits, withdrawals, outgoing and incoming payments) in a selected date range
+    
     private final TransactionStatistics totalAmount = new TransactionStatistics();
+    
     private final TransactionStatistics depositAmount = new TransactionStatistics(TransactionType.DEPOSIT);
+    
     private final TransactionStatistics withdrawalAmount = new TransactionStatistics(TransactionType.WITHDRAW);
+    
     private final TransactionStatistics crossAccountAmount = new TransactionStatistics(TransactionType.CROSS_ACCOUNT_PAYMENT);
+    
     private final TransactionStatistics creditAmount = new TransactionStatistics(TransactionType.CREDIT);
+    
     private final TransactionStatistics refundAmount = new TransactionStatistics(TransactionType.REFUND);
 
     //maybe not needed
     private BigDecimal amountMin = BigDecimal.valueOf(Double.MAX_VALUE);
+
     private BigDecimal amountMax = new BigDecimal(0);
 
     public StatisticalReport(List<Transaction> list) {

account-query/src/main/java/cz/muni/pa165/banking/domain/report/TransactionStatistics.java

@@ -3,20 +3,26 @@ package cz.muni.pa165.banking.domain.report;
 import cz.muni.pa165.banking.domain.transaction.TransactionType;
 
 import java.math.BigDecimal;
-import java.math.RoundingMode;
 
 /**
  * @author Martin Mojzis
  */
 public class TransactionStatistics {
+
     private TransactionType type = null;
+
     private BigDecimal amountIn = new BigDecimal(0);
+
     private BigDecimal amountOut = new BigDecimal(0);
+
     private Integer timesIn = 0;
+
     private Integer timesOut = 0;
+    
     public TransactionStatistics(TransactionType type){
         this.type = type;
     }
+    
     public TransactionStatistics(){}
 
     public void AddAmount(BigDecimal amount){

account-query/src/main/java/cz/muni/pa165/banking/domain/transaction/Transaction.java

@@ -2,23 +2,28 @@ package cz.muni.pa165.banking.domain.transaction;
 
 import java.math.BigDecimal;
 import java.time.OffsetDateTime;
-import java.util.Date;
+import java.util.UUID;
 
 /**
  * @author Martin Mojzis
  */
 public class Transaction {
+    
     private final TransactionType type;
+    
     private final BigDecimal amount;
+    
     private final OffsetDateTime date;
-    private final String processId;
+    
+    private final UUID processId;
 
-    public Transaction(TransactionType type, BigDecimal amount, OffsetDateTime date, String processId) {
+    public Transaction(TransactionType type, BigDecimal amount, OffsetDateTime date, UUID processId) {
         this.type = type;
         this.amount = amount;
         this.date = date;
         this.processId = processId;
     }
+    
     public OffsetDateTime getDate() {
         return date;
     }
@@ -30,7 +35,8 @@ public class Transaction {
     public TransactionType getType() {
         return type;
     }
-    public String getProcessId() {
+    
+    public UUID getProcessId() {
         return processId;
     }
 }

account-query/src/main/resources/openapi.yaml

@@ -35,6 +35,7 @@ components:
           format: date-time
         processId:
           type: string
+          format: uuid
           description: id of transaction issued by transaction processor
 
     Balance:
@@ -123,7 +124,7 @@ paths:
       parameters:
         - { name: id, in: query, required: true, schema: { type: string }, description: "id of account" }
         - { name: amount, in: query, required: true, schema: { type: number }, description: "amount of money in transaction" }
-        - { name: processId, in: query, required: true, schema: { type: string }, description: "id of process which this transaction is part of" }
+        - { name: processId, in: query, required: true, schema: { type: string, format: uuid }, description: "id of process which this transaction is part of" }
         - { name: type, in: query, required: true, schema: { $ref: "#/components/schemas/TransactionType" }, description: "type  of transaction" }
       responses:
         "200":