Enterprise Integration API

A reference .NET API that demonstrates enterprise integration patterns across Dynamics 365, SAP, CRM, ERP and external REST APIs using clean boundaries and production-oriented tooling.

This repository is intentionally fictional. It shows architecture, engineering discipline and integration thinking without exposing client, employer or proprietary code.

System View

flowchart LR
    Client["API Client"] --> Auth["JWT Auth"]
    Auth --> Api["ASP.NET Core API"]
    Api --> App["Application Use Cases"]
    App --> Domain["Domain Rules"]
    App --> Db["PostgreSQL"]
    App --> Cache["Redis Cache"]
    App --> Bus["RabbitMQ Exchange"]
    Bus --> Targets["Dynamics / SAP / CRM / ERP / REST"]

Loading

Highlights

• ASP.NET Core API on .NET 10
• JWT authentication and role-based authorization
• Swagger/OpenAPI documentation
• PostgreSQL persistence with EF Core
• Redis distributed cache
• RabbitMQ topic exchange for integration dispatch
• Domain-driven state transitions and audit trail
• Docker Compose for local infrastructure
• Unit tests for domain, application and persistence behavior
• GitHub Actions CI with build, tests and Docker image validation

What This Demonstrates

• Enterprise integration boundary design across heterogeneous systems.
• Durable job state, audit history and controlled dispatch to messaging infrastructure.
• Clean separation between API, application, domain and infrastructure concerns.
• Public-safe architecture storytelling using fictitious systems and payloads.

Architecture

src/
  EnterpriseIntegration.Api             HTTP, Swagger, auth, error handling
  EnterpriseIntegration.Application     Use cases, validation, ports
  EnterpriseIntegration.Domain          Entities, enums, business rules
  EnterpriseIntegration.Infrastructure  EF Core, Redis, RabbitMQ, JWT
tests/
  EnterpriseIntegration.UnitTests       Domain, application and repository tests

More detail is available in docs/architecture.md.

Run Locally

Prerequisites

• .NET 10 SDK
• Docker and Docker Compose

Start the full stack

docker compose up --build

Services:

• API: http://localhost:8080
• Swagger: http://localhost:8080/swagger
• PostgreSQL: localhost:5432
• Redis: localhost:6379
• RabbitMQ Management: http://localhost:15672

RabbitMQ credentials:

enterprise / enterprise

Demo API credentials:

victor / ChangeMe123!

API Flow

1. Generate a token:

POST /api/v1/auth/token
Content-Type: application/json

{
  "username": "victor",
  "password": "ChangeMe123!"
}

2. Create an integration job:

POST /api/v1/integration-jobs
Authorization: Bearer <token>
Content-Type: application/json

{
  "sourceSystem": "Dynamics365",
  "targetSystem": "Sap",
  "entityType": "SalesOrder",
  "requestedBy": "victor.siqueira",
  "payload": {
    "salesOrderNumber": "SO-100045",
    "customerAccount": "C-00991",
    "currency": "BRL",
    "totalAmount": 15900.75
  }
}

3. Dispatch the job to RabbitMQ:

POST /api/v1/integration-jobs/{id}/dispatch
Authorization: Bearer <token>

Test

dotnet restore EnterpriseIntegrationApi.slnx
dotnet build EnterpriseIntegrationApi.slnx
dotnet test EnterpriseIntegrationApi.slnx

Security Notes

The included usernames, passwords and signing key are local development defaults. Replace them with environment variables or a secret manager before deploying this pattern anywhere outside a local demo environment.

Why This Exists

Senior engineers often cannot publish client or employer code. This project demonstrates how to communicate enterprise software experience through open, fictional, well-structured samples.

Author & Contact

Built and maintained by Victor Henrique de Siqueira.

• Email: victor.h.siqueira@hotmail.com
• Phone / WhatsApp: +55 11 94340-3468
• GitHub: vsiqueiravh-cell

Portfolio Notice

This repository is part of a public enterprise software portfolio. All systems, payloads, users, credentials and integration scenarios are fictional and created only to demonstrate architecture and engineering approach.