Context Mapping（上下文映射）

// === Anti-Corruption Layer 範例 ===
// 上游：第三方支付 API（你無法控制它的模型）
namespace ExternalPayment
{
    // 第三方的回應格式（你不能改）
    public class PaymentGatewayResponse
    {
        public string txn_id { get; set; }
        public string status_code { get; set; }    // "00" = 成功
        public long amount_cents { get; set; }       // 金額用「分」
        public string currency_code { get; set; }
    }
}
 
// 下游：你的 Billing BC，用 ACL 隔離
namespace Billing.Infrastructure.Acl
{
    // ACL：把第三方的模型翻譯成自己的
    public class PaymentGatewayAdapter : IPaymentGateway
    {
        private readonly ExternalPaymentClient _client;
 
        public PaymentGatewayAdapter(ExternalPaymentClient client)
        {
            _client = client;
        }
 
        public async Task<PaymentResult> ProcessPayment(Money amount, PaymentMethod method)
        {
            // 轉換成第三方的格式
            var request = new ExternalPaymentRequest
            {
                AmountCents = (long)(amount.Amount * 100),
                CurrencyCode = amount.Currency,
                Method = MapPaymentMethod(method),
            };
 
            var response = await _client.Charge(request);
 
            // ACL：把第三方回應翻譯成自己的 Domain 模型
            return new PaymentResult(
                TransactionId: new TransactionId(response.txn_id),
                Status: MapStatus(response.status_code),
                Amount: new Money(response.amount_cents / 100m, response.currency_code)
            );
        }
 
        private PaymentStatus MapStatus(string code) => code switch
        {
            "00" => PaymentStatus.Succeeded,
            "01" => PaymentStatus.Declined,
            _    => PaymentStatus.Failed,
        };
    }
}
 
// === Open Host Service 範例 ===
namespace Sales.Api
{
    // 對外公開的 API — Published Language
    [ApiController]
    [Route("api/v1/orders")]
    public class OrdersController : ControllerBase
    {
        [HttpGet("{id}")]
        public async Task<OrderDto> GetOrder(Guid id)
        {
            var order = await _orderRepository.GetById(id);
            return OrderDtoMapper.ToDto(order); // 用 DTO 對外，不暴露 Domain Model
        }
    }
}

// === Anti-Corruption Layer ===
// 第三方支付的回應（你不能改）
interface PaymentGatewayResponse {
  txn_id: string;
  status_code: string; // "00" = 成功
  amount_cents: number;
  currency_code: string;
}
 
// ACL：翻譯成你的 Domain 模型
class PaymentGatewayAdapter implements PaymentGateway {
  constructor(private client: ExternalPaymentClient) {}
 
  async processPayment(amount: Money, method: PaymentMethod): Promise<PaymentResult> {
    const response = await this.client.charge({
      amountCents: Math.round(amount.amount * 100),
      currencyCode: amount.currency,
      method: this.mapMethod(method),
    });
 
    return {
      transactionId: new TransactionId(response.txn_id),
      status: this.mapStatus(response.status_code),
      amount: Money.create(response.amount_cents / 100, response.currency_code),
    };
  }
 
  private mapStatus(code: string): PaymentStatus {
    switch (code) {
      case "00": return PaymentStatus.Succeeded;
      case "01": return PaymentStatus.Declined;
      default:   return PaymentStatus.Failed;
    }
  }
}

# === Anti-Corruption Layer ===
from dataclasses import dataclass
 
@dataclass
class PaymentGatewayResponse:
    """第三方的回應（不能改）"""
    txn_id: str
    status_code: str
    amount_cents: int
    currency_code: str
 
class PaymentGatewayAdapter:
    """ACL：翻譯成 Domain 模型"""
    def __init__(self, client: ExternalPaymentClient):
        self._client = client
 
    async def process_payment(self, amount: Money, method: PaymentMethod) -> PaymentResult:
        response = await self._client.charge(
            amount_cents=int(amount.amount * 100),
            currency_code=amount.currency,
            method=self._map_method(method),
        )
        return PaymentResult(
            transaction_id=TransactionId(response.txn_id),
            status=self._map_status(response.status_code),
            amount=Money(response.amount_cents / 100, response.currency_code),
        )
 
    def _map_status(self, code: str) -> PaymentStatus:
        mapping = {"00": PaymentStatus.SUCCEEDED, "01": PaymentStatus.DECLINED}
        return mapping.get(code, PaymentStatus.FAILED)