Skip to content

endpoint description

Jump to bottom
Shelson Ferrari edited this page Jul 24, 2024 · 8 revisions

Endpoint Description

The Currency Conversion API provides endpoints for converting currency values. Below is a detailed description of the available endpoints, including methods, parameters, and usage examples.

Convert Currency Endpoint

Endpoint

GET /api/v1/conversions/convert

Description

Converts the source currency to the target currency.

Parameters

  • source (required): The source currency code (e.g., "USD").
  • target (required): The target currency code (e.g., "BRL").
  • amount (required): The amount to be converted.

List of Currency Codes

  • AED (UAE Dirham - United Arab Emirates)
  • AFN (Afghan Afghani - Afghanistan)
  • ALL (Albanian Lek - Albania)
  • AMD (Armenian Dram - Armenia)
  • ANG (Netherlands Antillian Guilder - Netherlands Antilles)
  • AOA (Angolan Kwanza - Angola)
  • ARS (Argentine Peso - Argentina)
  • AUD (Australian Dollar - Australia)
  • AWG (Aruban Florin - Aruba)
  • AZN (Azerbaijani Manat - Azerbaijan)
  • BAM (Bosnia and Herzegovina Mark - Bosnia and Herzegovina)
  • BBD (Barbados Dollar - Barbados)
  • BDT (Bangladeshi Taka - Bangladesh)
  • BGN (Bulgarian Lev - Bulgaria)
  • BHD (Bahraini Dinar - Bahrain)
  • BIF (Burundian Franc - Burundi)
  • BMD (Bermudian Dollar - Bermuda)
  • BND (Brunei Dollar - Brunei)
  • BOB (Bolivian Boliviano - Bolivia)
  • BRL (Brazilian Real - Brazil)
  • BSD (Bahamian Dollar - Bahamas)
  • BTN (Bhutanese Ngultrum - Bhutan)
  • BWP (Botswana Pula - Botswana)
  • BYN (Belarusian Ruble - Belarus)
  • BZD (Belize Dollar - Belize)
  • CAD (Canadian Dollar - Canada)
  • CDF (Congolese Franc - Democratic Republic of the Congo)
  • CHF (Swiss Franc - Switzerland)
  • CLP (Chilean Peso - Chile)
  • CNY (Chinese Renminbi - China)
  • COP (Colombian Peso - Colombia)
  • CRC (Costa Rican Colon - Costa Rica)
  • CUP (Cuban Peso - Cuba)
  • CVE (Cape Verdean Escudo - Cape Verde)
  • CZK (Czech Koruna - Czech Republic)
  • DJF (Djiboutian Franc - Djibouti)
  • DKK (Danish Krone - Denmark)
  • DOP (Dominican Peso - Dominican Republic)
  • DZD (Algerian Dinar - Algeria)
  • EGP (Egyptian Pound - Egypt)
  • ERN (Eritrean Nakfa - Eritrea)
  • ETB (Ethiopian Birr - Ethiopia)
  • EUR (Euro - European Union)
  • FJD (Fiji Dollar - Fiji)
  • FKP (Falkland Islands Pound - Falkland Islands)
  • FOK (Faroese Króna - Faroe Islands)
  • GBP (Pound Sterling - United Kingdom)
  • GEL (Georgian Lari - Georgia)
  • GGP (Guernsey Pound - Guernsey)
  • GHS (Ghanaian Cedi - Ghana)
  • GIP (Gibraltar Pound - Gibraltar)
  • GMD (Gambian Dalasi - The Gambia)
  • GNF (Guinean Franc - Guinea)
  • GTQ (Guatemalan Quetzal - Guatemala)
  • GYD (Guyanese Dollar - Guyana)
  • HKD (Hong Kong Dollar - Hong Kong)
  • HNL (Honduran Lempira - Honduras)
  • HRK (Croatian Kuna - Croatia)
  • HTG (Haitian Gourde - Haiti)
  • HUF (Hungarian Forint - Hungary)
  • IDR (Indonesian Rupiah - Indonesia)
  • ILS (Israeli New Shekel - Israel)
  • IMP (Manx Pound - Isle of Man)
  • INR (Indian Rupee - India)
  • IQD (Iraqi Dinar - Iraq)
  • IRR (Iranian Rial - Iran)
  • ISK (Icelandic Króna - Iceland)
  • JEP (Jersey Pound - Jersey)
  • JMD (Jamaican Dollar - Jamaica)
  • JOD (Jordanian Dinar - Jordan)
  • JPY (Japanese Yen - Japan)
  • KES (Kenyan Shilling - Kenya)
  • KGS (Kyrgyzstani Som - Kyrgyzstan)
  • KHR (Cambodian Riel - Cambodia)
  • KID (Kiribati Dollar - Kiribati)
  • KMF (Comorian Franc - Comoros)
  • KRW (South Korean Won - South Korea)
  • KWD (Kuwaiti Dinar - Kuwait)
  • KYD (Cayman Islands Dollar - Cayman Islands)
  • KZT (Kazakhstani Tenge - Kazakhstan)
  • LAK (Lao Kip - Laos)
  • LBP (Lebanese Pound - Lebanon)
  • LKR (Sri Lanka Rupee - Sri Lanka)
  • LRD (Liberian Dollar - Liberia)
  • LSL (Lesotho Loti - Lesotho)
  • LYD (Libyan Dinar - Libya)
  • MAD (Moroccan Dirham - Morocco)
  • MDL (Moldovan Leu - Moldova)
  • MGA (Malagasy Ariary - Madagascar)
  • MKD (Macedonian Denar - North Macedonia)
  • MMK (Burmese Kyat - Myanmar)
  • MNT (Mongolian Tögrög - Mongolia)
  • MOP (Macanese Pataca - Macau)
  • MRU (Mauritanian Ouguiya - Mauritania)
  • MUR (Mauritian Rupee - Mauritius)
  • MVR (Maldivian Rufiyaa - Maldives)
  • MWK (Malawian Kwacha - Malawi)
  • MXN (Mexican Peso - Mexico)
  • MYR (Malaysian Ringgit - Malaysia)
  • MZN (Mozambican Metical - Mozambique)
  • NAD (Namibian Dollar - Namibia)
  • NGN (Nigerian Naira - Nigeria)
  • NIO (Nicaraguan Córdoba - Nicaragua)
  • NOK (Norwegian Krone - Norway)
  • NPR (Nepalese Rupee - Nepal)
  • NZD (New Zealand Dollar - New Zealand)
  • OMR (Omani Rial - Oman)
  • PAB (Panamanian Balboa - Panama)
  • PEN (Peruvian Sol - Peru)
  • PGK (Papua New Guinean Kina - Papua New Guinea)
  • PHP (Philippine Peso - Philippines)
  • PKR (Pakistani Rupee - Pakistan)
  • PLN (Polish Złoty - Poland)
  • PYG (Paraguayan Guaraní - Paraguay)
  • QAR (Qatari Riyal - Qatar)
  • RON (Romanian Leu - Romania)
  • RSD (Serbian Dinar - Serbia)
  • RUB (Russian Ruble - Russia)
  • RWF (Rwandan Franc - Rwanda)
  • SAR (Saudi Riyal - Saudi Arabia)
  • SBD (Solomon Islands Dollar - Solomon Islands)
  • SCR (Seychellois Rupee - Seychelles)
  • SDG (Sudanese Pound - Sudan)
  • SEK (Swedish Krona - Sweden)
  • SGD (Singapore Dollar - Singapore)
  • SHP (Saint Helena Pound - Saint Helena)
  • SLE (Sierra Leonean Leone - Sierra Leone)
  • SOS (Somali Shilling - Somalia)
  • SRD (Surinamese Dollar - Suriname)
  • SSP (South Sudanese Pound - South Sudan)
  • STN (São Tomé and Príncipe Dobra - São Tomé and Príncipe)
  • SYP (Syrian Pound - Syria)
  • SZL (Eswatini Lilangeni - Eswatini)
  • THB (Thai Baht - Thailand)
  • TJS (Tajikistani Somoni - Tajikistan)
  • TMT (Turkmenistan Manat - Turkmenistan)
  • TND (Tunisian Dinar - Tunisia)
  • TOP (Tongan Paʻanga - Tonga)
  • TRY (Turkish Lira - Turkey)
  • TTD (Trinidad and Tobago Dollar - Trinidad and Tobago)
  • TVD (Tuvaluan Dollar - Tuvalu)
  • TWD (New Taiwan Dollar - Taiwan)
  • TZS (Tanzanian Shilling - Tanzania)
  • UAH (Ukrainian Hryvnia - Ukraine)
  • UGX (Ugandan Shilling - Uganda)
  • USD (United States Dollar - United States)
  • UYU (Uruguayan Peso - Uruguay)
  • UZS (Uzbekistani So'm - Uzbekistan)
  • VES (Venezuelan Bolívar Soberano - Venezuela)
  • VND (Vietnamese Đồng - Vietnam)
  • VUV (Vanuatu Vatu - Vanuatu)
  • WST (Samoan Tālā - Samoa)
  • XAF (Central African CFA Franc - CEMAC)
  • XCD (East Caribbean Dollar - Organisation of Eastern Caribbean States)
  • XDR (Special Drawing Rights - International Monetary Fund)
  • XOF (West African CFA franc - CFA)
  • XPF (CFP Franc - Collectivités d'Outre-Mer)
  • YER (Yemeni Rial - Yemen)
  • ZAR (South African Rand - South Africa)
  • ZMW (Zambian Kwacha - Zambia)
  • ZWL (Zimbabwean Dollar - Zimbabwe)

Example Request

curl -X GET "http://localhost:8080/api/v1/conversions/convert?source=USD&target=BRL&amount=100" -H "Accept: application/json"

Example Response

{
  "sourceCurrency": "USD",
  "targetCurrency": "BRL",
  "conversionRate": 5.25,
  "queryDate": "2024-07-12T18:12:24",
  "amount": 100.0,
  "convertedAmount": 525.0
}

Response Codes

  • 200 OK: Successful operation.
  • 400 Bad Request: Invalid input parameters.

Swagger Documentation

The API is documented using Swagger. You can access the interactive API documentation at http://localhost:8080/swagger-ui/.

Swagger Configuration in pom.xml 

<dependency>
    <groupId>io.swagger</groupId>
    <artifactId>swagger-annotations</artifactId>
    <version>1.5.21</version>
</dependency>
<dependency>
    <groupId>io.swagger</groupId>
    <artifactId>swagger-models</artifactId>
    <version>1.5.21</version>
</dependency>

<plugin>
    <groupId>com.github.kongchen</groupId>
    <artifactId>swagger-maven-plugin</artifactId>
    <version>3.1.8</version>
    <configuration>
        <apiSources>
            <apiSource>
                <springmvc>true</springmvc>
                <locations>com.shelson.application</locations>
                <schemes>http,https</schemes>
                <host>localhost:8080</host>
                <basePath>/api-doc</basePath>
                <info>
                    <title>Currency Conversion API</title>
                    <version>v1</version>
                    <description>API for converting currency rates</description>
                    <contact>
                        <email>shelson@gmail.com</email>
                        <name>Shelson Ferrari</name>
                        <url>https://about.me/shelson</url>
                    </contact>
                    <license>
                        <url>https://github.com/33mestre/java_base/blob/master/LICENSES</url>
                        <name>Dual Licence - MIT License and Apache License 2.0</name>
                    </license>
                </info>
                <outputFormats>json,yaml</outputFormats>
                <outputPath>sys/swagger</outputPath>
                <swaggerDirectory>sys</swaggerDirectory>
                <securityDefinitions>
                    <securityDefinition>
                        <name>basicAuth</name>
                        <type>basic</type>
                    </securityDefinition>
                </securityDefinitions>
            </apiSource>
        </apiSources>
    </configuration>
</plugin>

The openapi/swagger.json and openapi/swagger.yaml files are generated dynamically by the CI/CD process.

CI/CD Process to Generate Swagger Files

Generating Swagger Files

The following command is used to generate the Swagger files during the build process:

mvn clean install swagger:generate

Retrieving SHA of Files in CI/CD

The following CI/CD configuration snippet retrieves the SHA of specified files and sets them as environment variables:

# Gets the SHA of specified files if they exist and sets them as environment variables
# Files: CHANGELOG.md, .env, DIRECTORY.md, openapi/swagger.json, openapi/swagger.yaml

- name: Get SHA of files if they exist
  if: env.is_primary == 'true'
  id: get-sha
  run: |
    # Function to get the SHA of a file and set it as an environment variable
    get_sha() {
      local file_path=$1
      local var_name=$2
      local sha=$(curl -s -H "Authorization: Bearer $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/${{ github.repository }}/contents/$file_path | jq -r .sha)
      if [ "$sha" != "null" ]; then
        echo "${var_name}=${sha}" >> $GITHUB_ENV
      else
        echo "${var_name}=" >> $GITHUB_ENV
      fi
    }

    get_sha "CHANGELOG.md" "changelog_sha"
    get_sha ".env" "env_sha"
    get_sha "DIRECTORY.md" "directory_sha"
    get_sha "openapi/swagger.json" "swagger_json_sha"
    get_sha "openapi/swagger.yaml" "swagger_yaml_sha"
  env:
    GITHUB_TOKEN: ${{ secrets.TOKEN }}

Controller Documentation

CurrencyConversionController

This controller handles currency conversion operations and provides an endpoint for converting values between different currencies.

package com.shelson.application.controller;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import org.apache.camel.ProducerTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.shelson.application.dto.CurrencyConversionDTO;
import com.shelson.domain.model.Currency;
import com.shelson.infrastructure.exception.BusinessException;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import jakarta.servlet.http.HttpServletRequest;

/**
 * Controller responsible for handling currency conversion requests.
 * This controller provides an endpoint to convert a given amount from a source currency to a target currency.
 * It utilizes Apache Camel routes for fetching the exchange rates and performing the conversion.
 * 
 * Validations performed by this class:
 * <ul>
 *     <li>Ensures that the source and target currency codes are valid.</li>
 *     <li>Ensures that the amount to be converted is greater than zero.</li>
 *     <li>Checks for any unexpected parameters in the request and throws a BusinessException if found.</li>
 * </ul>
 * 
 * Example usage:
 * <pre>
 * {@code
 * // URL: /api/v1/conversions/convert?source=USD&target=EUR&amount=100
 * CurrencyConversionDTO conversion = currencyConversionController.convertCurrency("USD", "EUR", 100.0);
 * System.out.println(conversion);
 * }
 * </pre>
 * 
 * @author Shelson Ferrari
 * @version 0.6.3
 * @since 2024-07-24
 * 
 * @see com.shelson.application.dto.CurrencyConversionDTO
 * @see com.shelson.application.service.CurrencyConversionService
 * @see org.apache.camel.ProducerTemplate
 */
@RestController
@RequestMapping("/api/v1/conversions")
@Api(value = "Currency Conversion Controller", description = "Operations for currency conversion")
public class CurrencyConversionController {

    @Autowired
    private ProducerTemplate producerTemplate;

    private static final Logger logger = LoggerFactory.getLogger(CurrencyConversionController.class);

    /**
     * Converts the source currency to the target currency.
     *
     * Validates the following conditions:
     * <ul>
     *     <li>Source currency code is valid.</li>
     *     <li>Target currency code is valid.</li>
     *     <li>Amount to be converted is greater than zero.</li>
     *     <li>No unexpected parameters are present in the request.</li>
     * </ul>
     *
     * @param source The source currency code.
     * @param target The target currency code.
     * @param amount The amount to be converted.
     * @param request The HttpServletRequest object to check for unexpected parameters.
     * @return The details of the currency conversion.
     * @throws BusinessException if the source or target currency is invalid or if there are unexpected parameters.
     */
    @GetMapping("/convert")
    @ApiOperation(value = "Converts the source currency to the target currency", notes = "Returns the currency conversion details")
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "Successful operation", response = CurrencyConversionDTO.class),
            @ApiResponse(code = 400, message = "Invalid input")
    })
    public CurrencyConversionDTO convertCurrency(
            @RequestParam @ApiParam(value = "Source currency", example = "USD") String source,
            @RequestParam @ApiParam(value = "Target currency", example = "BRL") String target,
            @RequestParam @ApiParam(value = "Amount to be converted", example = "100.0") double amount,
            HttpServletRequest request) throws BusinessException {

        logger.info("Received currency conversion request: source={}, target={}, amount={}", source, target, amount);

        // Validate that only the expected parameters are present
        validateParameters(request);

        try {
            Currency sourceCurrency = Currency.valueOf(source);
            Currency targetCurrency = Currency.valueOf(target);

            Map<String, Object> headers = new HashMap<>();
            headers.put("source", sourceCurrency);
            headers.put("target", targetCurrency);
            headers.put("amount", amount);

            CurrencyConversionDTO result = producerTemplate.requestBodyAndHeaders("direct:convertCurrency", null, headers, CurrencyConversionDTO.class);
            logger.info("Currency conversion successful: {}", result);
            return result;
        } catch (IllegalArgumentException ex) {
            logger.error("Invalid currency code provided: source={}, target={}", source, target, ex);
            throw new BusinessException("Invalid source or target currency");
        }
    }

    /**
     * Validates that no unexpected parameters are present in the request.
     *
     * @param request The HttpServletRequest object containing the request parameters.
     * @throws BusinessException if any unexpected parameters are found.
     */
    private void validateParameters(HttpServletRequest request) throws BusinessException {
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String paramName = parameterNames.nextElement();
            if (!paramName.equals("source") && !paramName.equals("target") && !paramName.equals("amount")) {
                logger.error("Unexpected parameter found: {}", paramName);
                throw new BusinessException("Unexpected parameter: " + paramName);
            }
        }
    }
}

The CurrencyConversionController class provides an endpoint for converting currency values. The Swagger annotations (@Api, @ApiOperation, @ApiResponses, and @ApiParam) are used to generate the Swagger documentation for this endpoint.

CurrencyConversionDTO

This DTO represents the details about the currency conversion and includes various fields with Swagger annotations to describe the properties.

/**
 * DTO that represents details about the currency conversion.
 * 
 * @version 0.6.3
 * @since 2024-07-24
 * @see com.shelson.domain.model.Currency
 * @see com.shelson.application.service.CurrencyConversionService
 * @see org.apache.camel.ProducerTemplate
 * @author Shelson Ferrari
 */
@ApiModel(description = "Details about the currency conversion")
public class CurrencyConversionDTO {

    @ApiModelProperty(value = "Source currency", example = "USD", required = true)
    @NotNull(message = "Source currency cannot be null")
    private Currency sourceCurrency;

    @ApiModelProperty(value = "Target currency", example = "BRL", required = true)
    @NotNull(message = "Target currency cannot be null")
    private Currency targetCurrency;

    @ApiModelProperty(value = "Conversion rate", example = "5.25", required = true)
    @Positive(message = "Conversion rate must be positive")
    private double conversionRate;

    @ApiModelProperty(value = "Query date and time", example = "2024-07-12T18:12:24", required = true)
    @PastOrPresent(message = "Query date cannot be in the future")
    private LocalDateTime queryDate;
    
    @ApiModelProperty(value = "Amount to be converted", example = "100.0", required = true)
    @Positive(message = "Amount must be greater than zero")
    private double amount;

    @ApiModelProperty(value = "Converted amount", example = "850.0", required = true)
    @Positive(message = "Converted amount must be greater than zero")
    private double convertedAmount;

    // Default constructor
    public CurrencyConversionDTO() {
    }

    // Constructor with all parameters
    public CurrencyConversionDTO(Currency sourceCurrency, Currency targetCurrency, double conversionRate, LocalDateTime queryDate, double amount, double convertedAmount) {
        this.sourceCurrency = sourceCurrency;
        this.targetCurrency = targetCurrency;
        this.conversionRate = conversionRate;
        this.queryDate = queryDate;
        this.amount = amount;
        this.convertedAmount = convertedAmount;
    }

    // Getters and Setters
    public Currency getSourceCurrency() {
        return sourceCurrency;
    }

    public void setSourceCurrency(Currency sourceCurrency) {
        this.sourceCurrency = sourceCurrency;
    }

    public Currency getTargetCurrency() {
        return targetCurrency;
    }

    public void setTargetCurrency(Currency targetCurrency) {
        this.targetCurrency = targetCurrency;
    }

    public double getConversionRate() {
        return conversionRate;
    }

    public void setConversionRate(double conversionRate) {
        this.conversionRate = conversionRate;
    }

    public LocalDateTime getQueryDate() {
        return queryDate;
    }

    public void setQueryDate(LocalDateTime queryDate) {
        this.queryDate = queryDate;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public double getConvertedAmount() {
        return convertedAmount;
    }

    public void setConvertedAmount(double convertedAmount) {
        this.convertedAmount = convertedAmount;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE)
                .append("sourceCurrency", sourceCurrency)
                .append("targetCurrency", targetCurrency)
                .append("conversionRate", conversionRate)
                .append("queryDate", queryDate)
                .append("amount", amount)
                .append("convertedAmount", convertedAmount)
                .toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        CurrencyConversionDTO that = (CurrencyConversionDTO) o;

        return new EqualsBuilder()
                .append(conversionRate, that.conversionRate)
                .append(amount, that.amount)
                .append(convertedAmount, that.convertedAmount)
                .append(sourceCurrency, that.sourceCurrency)
                .append(targetCurrency, that.targetCurrency)
                .append(queryDate, that.queryDate)
                .isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder(17, 37)
                .append(sourceCurrency)
                .append(targetCurrency)
                .append(conversionRate)
                .append(queryDate)
                .append(amount)
                .append(convertedAmount)
                .toHashCode();
    }
}

The CurrencyConversionDTO class represents the details of the currency conversion. It includes fields such as source currency, target currency, conversion rate, query date, amount, and converted amount. The Swagger annotations (@ApiModel and @ApiModelProperty) are used to generate the Swagger documentation for this DTO.

Swagger Annotations Explained

CurrencyConversionController

The CurrencyConversionController class uses several Swagger annotations to document the API endpoints.

  • @RestController: Indicates that this class is a REST controller.
  • @RequestMapping("/api/v1/conversions"): Specifies the base URL path for all endpoints in this controller.
  • @Api: Adds metadata about the controller for Swagger documentation.
    • value: A brief description of the controller.
    • description: A detailed description of the controller.

convertCurrency Method

  • @GetMapping("/convert"): Maps HTTP GET requests to this method, handling requests to /api/v1/conversions/convert.
  • @ApiOperation: Adds metadata about the operation for Swagger documentation.
    • value: A brief description of the operation.
    • notes: Additional information about the operation.
  • @ApiResponses: Defines the possible responses for the operation.
    • @ApiResponse: Describes a single response.
      • code: The HTTP status code of the response.
      • message: A brief description of the response.
      • response: The class of the response object.
  • @RequestParam: Maps a request parameter to a method parameter.
    • @ApiParam: Adds metadata about the parameter for Swagger documentation.
      • value: A brief description of the parameter.
      • example: An example value for the parameter.

CurrencyConversionDTO

The CurrencyConversionDTO class uses several Swagger annotations to document the model.

  • @ApiModel: Adds metadata about the model for Swagger documentation.
    • description: A brief description of the model.

Fields

  • @ApiModelProperty: Adds metadata about a field for Swagger documentation.
    • value: A brief description of the field.
    • example: An example value for the field.
    • required: Indicates whether the field is required.
  • @NotNull: Ensures that the field is not null.
    • message: The error message if the validation fails.
  • @Positive: Ensures that the field is a positive number.
    • message: The error message if the validation fails.
  • @PastOrPresent: Ensures that the field is a date in the past or present.
    • message: The error message if the validation fails.

Wiki Menu

Wiki Main Page

1. Introduction to the Project

  • Overview: Presentation of the project, highlighting its purpose and the context in which it is embedded.
  • Project Objectives: Enumeration of the main objectives that the project aims to achieve.
  • Scope and Functionalities: Description of the main functionalities offered by the project and its scope of operation.

2. Configuration and Installation

3. Project Structure

  • Folder Structure: Description of the organization of the project directories.
  • Project Architecture: Explanation of the architecture used, including design patterns and technical decisions.

4. Development

  • Development Flow: Description of the development process adopted, including planning, coding, and review stages.
  • Apache Camel Integration: Guide on integrating Apache Camel into the project, including configuration and usage.
  • Contributors and Authors: Recognition of the contributors to the project.
  • Contributions: Guidelines on how to contribute to the project, including code standards and pull request requirements, tips and best practices.
  • Code of Conduct: Behavioral guidelines expected for the project community.

5. API and Documentation

6. Endpoints and Database

  • Endpoint Description.
  • Database Management: Strategies and practices for efficient management of the database used by the project.

7. Testing

  • Testing Strategies: Approach and methods used to test the software, including unit, integration, and E2E tests.
  • Testing Tools: Description of the testing tools used in the project and how to configure them.

8. CI/CD and Automations

  • CI/CD Pipeline: Explanation of the continuous integration and delivery pipeline, detailing each stage and its function.
  • Automations and Artifact Generation: Description of the automations incorporated into the CI/CD, including documentation generation and build artifacts.

9. Configuration Files

10. Best Practices

11. Legal and Licensing

  • Licensing: Information about the rights and restrictions associated with the use of the software.
  • Terms of Use: Information about the terms and conditions for using the software.

12. Projections and Innovations

  • Future Plans: Discussion on functionalities and improvements considered for future versions of the project.
  • Improvement Proposals: Space for the community to suggest and debate improvements and innovations.

13. Attachments and Useful Links

14. Security

  • Security Policy: Details on the supported versions, reporting vulnerabilities, and general security practices.

Clone this wiki locally