validacao de valores melhores q zero no service q utiliza cammel - usando business exception e melhoria dos comentarios java doc

Author: Shelson Ferrari

src/main/java/com/shelson/application/controller/CurrencyConversionController.java

@@ -114,6 +114,12 @@ public CurrencyConversionDTO convertCurrency(
 
         // Validate that only the expected parameters are present
         validateParameters(request);
+        
+        // Validate the amount parameter
+        if (amount <= 0) {
+            logger.error("Invalid amount provided: {}", amount);
+            throw new BusinessException("Amount must be greater than zero");
+        }
 
         try {
             Currency sourceCurrency = Currency.valueOf(source);

src/main/java/com/shelson/application/service/CurrencyConversionService.java

@@ -23,7 +23,6 @@
 import org.apache.camel.ProducerTemplate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import com.fasterxml.jackson.core.type.TypeReference;
@@ -36,34 +35,50 @@
 import com.shelson.infrastructure.exception.ResourceNotFoundException;
 
 /**
- * Camel route for handling currency conversion requests.
- * This route takes the source currency, target currency, and amount as headers,
- * processes the conversion using the {@link CurrencyConversionService}, and returns the conversion details.
+ * Service responsible for handling currency conversion requests using Apache Camel.
+ * This service takes the source currency, target currency, and amount as parameters,
+ * performs the currency conversion, and returns the conversion details as a DTO.
+ * 
+ * <p>This service uses Apache Camel's {@link ProducerTemplate} to request exchange rates and
+ * interacts with the {@link CurrencyConversionRepository} to persist conversion records.
  * 
  * @version 0.6.3
  * @since 2024-07-24
  * 
  * @author Shelson Ferrari
  * 
  * @see com.shelson.application.dto.CurrencyConversionDTO
- * @see com.shelson.application.service.CurrencyConversionService
- * @see com.shelson.application.processors.ExchangeRateProcessor
- * @see org.apache.camel.ProducerTemplate
  * @see com.shelson.domain.model.Currency
+ * @see com.shelson.domain.model.CurrencyConversion
+ * @see com.shelson.domain.repository.CurrencyConversionRepository
+ * @see com.shelson.infrastructure.exception.BusinessException
+ * @see com.shelson.infrastructure.exception.ResourceNotFoundException
+ * @see org.apache.camel.ProducerTemplate
  */
 @Service
 public class CurrencyConversionService {
 
-    @Autowired
-    private ProducerTemplate producerTemplate;
-
-    @Autowired
-    private CurrencyConversionRepository repository;
+    private final ProducerTemplate producerTemplate;
+    private final CurrencyConversionRepository repository;
+    private final ObjectMapper objectMapper;
 
     private static final Logger logger = LoggerFactory.getLogger(CurrencyConversionService.class);
 
-    private final ObjectMapper objectMapper = new ObjectMapper();
-
+    /**
+     * Constructs a {@code CurrencyConversionService} with the specified dependencies.
+     * 
+     * @param producerTemplate The Apache Camel {@link ProducerTemplate} used to request exchange rates.
+     * @param repository The {@link CurrencyConversionRepository} used to save currency conversion records.
+     * @param objectMapper The {@link ObjectMapper} used to parse and convert JSON data.
+     */
+    public CurrencyConversionService(ProducerTemplate producerTemplate, 
+                                     CurrencyConversionRepository repository, 
+                                     ObjectMapper objectMapper) {
+        this.producerTemplate = producerTemplate;
+        this.repository = repository;
+        this.objectMapper = objectMapper;
+    }
+    
     /**
      * Converts the given amount from the source currency to the target currency.
      *
@@ -77,6 +92,25 @@ public class CurrencyConversionService {
     public CurrencyConversionDTO convertCurrency(Currency sourceCurrency, Currency targetCurrency, double amount) {
         logger.info("Starting currency conversion: source={}, target={}, amount={}", sourceCurrency, targetCurrency, amount);
 
+        validateInputs(sourceCurrency, targetCurrency, amount);
+        Map<String, Double> rates = fetchExchangeRates(sourceCurrency);
+
+        Double rate = getRateForTargetCurrency(rates, targetCurrency);
+        double convertedAmount = calculateConvertedAmount(amount, rate);
+
+        CurrencyConversion conversion = saveCurrencyConversion(sourceCurrency, targetCurrency, rate);
+        return buildCurrencyConversionDTO(sourceCurrency, targetCurrency, amount, convertedAmount, conversion);
+    }
+
+    /**
+     * Validates the input parameters for currency conversion.
+     * 
+     * @param sourceCurrency The source {@link Currency} to convert from.
+     * @param targetCurrency The target {@link Currency} to convert to.
+     * @param amount The amount to be converted.
+     * @throws BusinessException if sourceCurrency or targetCurrency is null, or if the amount is less than or equal to zero.
+     */
+    private void validateInputs(Currency sourceCurrency, Currency targetCurrency, double amount) {
         if (sourceCurrency == null || targetCurrency == null) {
             logger.error("Source or target currency is null");
             throw new BusinessException("Source and target currencies must not be null");
@@ -85,31 +119,82 @@ public CurrencyConversionDTO convertCurrency(Currency sourceCurrency, Currency t
             logger.error("Invalid amount: {}", amount);
             throw new BusinessException("Amount must be greater than zero");
         }
+    }
 
-        Map<String, Double> rates = null;
+    /**
+     * Fetches exchange rates from an external service.
+     * 
+     * @param sourceCurrency The source {@link Currency} for which the exchange rates are requested.
+     * @return A {@link Map} containing the exchange rates, where the keys are currency codes and the values are rates.
+     * @throws ResourceNotFoundException if an error occurs while fetching the exchange rates.
+     */
+    private Map<String, Double> fetchExchangeRates(Currency sourceCurrency) {
         try {
             Object response = producerTemplate.requestBodyAndHeader("direct:fetchRate", null, "sourceCurrency", sourceCurrency.getCode());
             if (response != null) {
-                rates = objectMapper.convertValue(response, new TypeReference<Map<String, Double>>() {});
-                logger.info("Fetched exchange rates: {}", rates);
+                return objectMapper.convertValue(response, new TypeReference<Map<String, Double>>() {});
             }
         } catch (Exception ex) {
             logger.error("Error fetching exchange rates from API: {}", ex.getMessage());
             throw new ResourceNotFoundException("Error fetching exchange rates from API", ex);
         }
+        return null;
+    }
 
+    /**
+     * Retrieves the exchange rate for the target currency from the fetched rates.
+     * 
+     * @param rates A {@link Map} containing the exchange rates.
+     * @param targetCurrency The target {@link Currency} for which the rate is needed.
+     * @return The exchange rate for the target currency.
+     * @throws BusinessException if the target currency rate is invalid or missing.
+     */
+    private Double getRateForTargetCurrency(Map<String, Double> rates, Currency targetCurrency) {
         if (rates == null || !rates.containsKey(targetCurrency.getCode())) {
             logger.error("Invalid or missing target currency rate: {}", targetCurrency);
             throw new BusinessException("Invalid or missing target currency rate");
         }
+        return rates.get(targetCurrency.getCode());
+    }
 
-        Double rate = rates.get(targetCurrency.getCode());
-        double convertedAmount = amount * rate;
+    /**
+     * Calculates the converted amount based on the given amount and exchange rate.
+     * 
+     * @param amount The amount to be converted.
+     * @param rate The exchange rate to be used for conversion.
+     * @return The converted amount.
+     */
+    private double calculateConvertedAmount(double amount, Double rate) {
+        return amount * rate;
+    }
+
+    /**
+     * Saves the currency conversion record to the repository.
+     * 
+     * @param sourceCurrency The source {@link Currency}.
+     * @param targetCurrency The target {@link Currency}.
+     * @param rate The exchange rate used for conversion.
+     * @return The {@link CurrencyConversion} record that was saved.
+     */
+    private CurrencyConversion saveCurrencyConversion(Currency sourceCurrency, Currency targetCurrency, Double rate) {
         CurrencyConversion conversion = new CurrencyConversion(sourceCurrency, targetCurrency, rate, LocalDateTime.now());
         repository.save(conversion);
         logger.info("Currency conversion saved: {}", conversion);
+        return conversion;
+    }
 
-        CurrencyConversionDTO result = new CurrencyConversionDTO(sourceCurrency, targetCurrency, rate, LocalDateTime.now(), amount, convertedAmount);
+    /**
+     * Builds a {@link CurrencyConversionDTO} with the conversion details.
+     * 
+     * @param sourceCurrency The source {@link Currency}.
+     * @param targetCurrency The target {@link Currency}.
+     * @param amount The amount to be converted.
+     * @param convertedAmount The result of the conversion.
+     * @param conversion The {@link CurrencyConversion} record used for creating the DTO.
+     * @return A {@link CurrencyConversionDTO} containing the conversion details.
+     */
+    private CurrencyConversionDTO buildCurrencyConversionDTO(Currency sourceCurrency, Currency targetCurrency, double amount, double convertedAmount, CurrencyConversion conversion) {
+        CurrencyConversionDTO result = new CurrencyConversionDTO(sourceCurrency, targetCurrency, conversion.getConversionRate(), conversion.getQueryDate(), amount, convertedAmount);
         logger.info("Conversion result: {}", result);
         return result;
     }