아웃바운드 룰

시나리오: 금융 전문 번호 매칭 (고정 길이)

요청 전문 구조:
- 전문 번호 (txNo): offset 0, length 10

응답 전문 구조:
- 전문 번호 (txNo): offset 0, length 10

설정:
- 매칭 메시지 타입: FIXED
- 요청 필드: txNo
- 응답 필드: txNo

시나리오: REST API 요청 ID 매칭

요청 JSON:
{
  "requestId": "REQ-20250205-001",
  "data": { ... }
}

응답 JSON:
{
  "requestId": "REQ-20250205-001",
  "result": { ... }
}

설정:
- 매칭 메시지 타입: JSON
- 요청 필드: requestId
- 응답 필드: requestId

프로토콜: FTP
FTP Rule 타입: GET
타임아웃: 60000ms (60초)

소스 > 디렉터리: /remote/data
소스 > 파일 패턴: *.csv
대상 > 디렉터리: /local/download

전송 파일 타입: BINARY

프로토콜: FTP
FTP Rule 타입: PUT
타임아웃: 120000ms (120초)

소스 > 디렉터리: /local/outgoing
소스 > 파일 패턴: report_*.pdf
대상 > 디렉터리: /remote/reports

전송 파일 타입: BINARY
최대 파일 개수 제한: 사용
최대 파일 개수: 10

프로토콜: FTP
FTP Rule 타입: LS
타임아웃: 10000ms (10초)

소스 > 디렉터리: /remote/data
소스 > 파일 패턴: *

응답 매핑 > 파일 이름: 응답 메시지의 fileList 필드

프로토콜: FTP
FTP Rule 타입: MV
타임아웃: 30000ms (30초)

소스 > 디렉터리: /remote/incoming
소스 > 파일 패턴: processed_*.dat
대상 > 디렉터리: /remote/archive

# 날짜 기반 디렉터리
/data/backup/${date:yyyyMMdd}

# 날짜 기반 파일 이름
report_${date:yyyyMMdd}.csv

프로토콜: FILE
FILE 룰 타입: READ
타임아웃: 30000ms (30초)

파일 경로: /data/incoming
파일 이름: data_*.json
데이터 모드: Bulk

처리 후 동작: 이동
처리 후 동작 파라미터: /data/processed

응답 파일 내용: 응답 메시지의 content 필드
응답 파일 이름: 응답 메시지의 fileName 필드

프로토콜: FILE
FILE 룰 타입: READ
타임아웃: 10000ms (10초)

파일 경로: /data/reports
파일 이름: *.csv
하위 폴더 조회 여부: 조회
데이터 모드: Info

파일 처리 순서: 수정일
정렬: 내림차순

응답 파일 경로: 응답 메시지의 filePath 필드
응답 파일 이름: 응답 메시지의 fileName 필드
응답 파일 크기: 응답 메시지의 fileSize 필드

프로토콜: FILE
FILE 룰 타입: READ
타임아웃: 10000ms (10초)

파일 경로: /data/temp
파일 이름: *.log
데이터 모드: Skip

처리 후 동작: 이동
처리 후 동작 파라미터: /data/archive/${date:yyyyMMdd}

프로토콜: FILE
FILE 룰 타입: WRITE
타임아웃: 30000ms (30초)

파일 경로: /data/outgoing
파일 이름: report_${date:yyyyMMdd}.csv
데이터 모드: Bulk

파일 쓰기 모드: 덮어 쓰기
기존 파일 삭제 여부: 삭제

요청 파일 내용: 요청 메시지의 reportData 필드

SQL 결과 컬럼          →  응답 메시지 필드
-----------------          -----------------
customer_id           →  customerId
customer_name         →  customerName
email                 →  email
registration_date     →  registrationDate

SQL: SELECT customer_id, customer_name FROM customers WHERE id = '${CustomerSearchRequest/id}'

결과:
| customer_id | customer_name |
|-------------|---------------|
| C001        | 홍길동        |

매핑 결과:
{
  "customerId": "C001",
  "customerName": "홍길동"
}

SQL: SELECT order_id, order_date FROM orders WHERE customer_id = '${OrderSearchRequest/customerId}'

결과:
| order_id | order_date |
|----------|------------|
| ORD001   | 2025-02-01 |
| ORD002   | 2025-02-03 |
| ORD003   | 2025-02-05 |

매핑 결과 (배열 필드인 경우):
{
  "orders": [
    {"orderId": "ORD001", "orderDate": "2025-02-01"},
    {"orderId": "ORD002", "orderDate": "2025-02-03"},
    {"orderId": "ORD003", "orderDate": "2025-02-05"}
  ]
}

-- SQL #0: 고객 정보 조회
SELECT customer_id, customer_name
FROM customers
WHERE customer_id = '${CustomerInfoRequest/customerId}'

-- SQL #1: 주문 목록 조회
SELECT order_id, order_date, total_amount
FROM orders
WHERE customer_id = '${CustomerInfoRequest/customerId}'
ORDER BY order_date DESC

-- SQL #2: 적립 포인트 조회
SELECT point_balance
FROM customer_points
WHERE customer_id = '${CustomerInfoRequest/customerId}'

인덱스 0 (고객 정보):
  customer_id → customerId
  customer_name → customerName

인덱스 1 (주문 목록):
  order_id → orders[].orderId
  order_date → orders[].orderDate
  total_amount → orders[].totalAmount

인덱스 2 (적립 포인트):
  point_balance → pointBalance

프로토콜: DB
타임아웃: 30000ms (30초)

SQL 에디터:
  SELECT product_id, product_name, price, stock_quantity
  FROM products
  WHERE category = '${ProductSearchRequest/category}'
    AND price <= ${ProductSearchRequest/maxPrice}
    AND stock_quantity > 0
  ORDER BY price ASC

요청 메시지: ProductSearchRequest
  - category: STRING
  - maxPrice: LONG

응답 메시지: ProductSearchResponse
  - products: OBJECT (배열)
    - productId: STRING
    - productName: STRING
    - price: LONG
    - stockQuantity: INT

출력 매핑:
  인덱스 0:
    product_id → productId
    product_name → productName
    price → price
    stock_quantity → stockQuantity

프로토콜: DB
타임아웃: 10000ms (10초)

SQL 에디터:
  INSERT INTO orders (
    order_id, customer_id, order_date,
    total_amount, status
  )
  VALUES (
    '${OrderCreateRequest/orderId}', '${OrderCreateRequest/customerId}',
    '${OrderCreateRequest/orderDate}', ${OrderCreateRequest/totalAmount}, 'PENDING'
  )

요청 메시지: OrderCreateRequest
  - orderId: STRING
  - customerId: STRING
  - orderDate: STRING
  - totalAmount: LONG

프로토콜: DB
타임아웃: 10000ms (10초)

SQL 에디터:
  UPDATE orders
  SET status = '${OrderStatusUpdateRequest/newStatus}',
      updated_at = NOW()
  WHERE order_id = '${OrderStatusUpdateRequest/orderId}'
    AND status = '${OrderStatusUpdateRequest/currentStatus}'

요청 메시지: OrderStatusUpdateRequest
  - orderId: STRING
  - currentStatus: STRING
  - newStatus: STRING

프로토콜: DB
타임아웃: 30000ms (30초)

SQL 에디터:
  -- SQL #0: 주문 생성
  INSERT INTO orders (order_id, customer_id, total_amount, status)
  VALUES ('${OrderProcessRequest/orderId}', '${OrderProcessRequest/customerId}',
          ${OrderProcessRequest/totalAmount}, 'CONFIRMED')

  -- SQL #1: 주문 상세 생성
  INSERT INTO order_items (order_id, product_id, quantity, unit_price)
  VALUES ('${OrderProcessRequest/orderId}', '${OrderProcessRequest/productId}',
          ${OrderProcessRequest/quantity}, ${OrderProcessRequest/unitPrice})

  -- SQL #2: 재고 차감
  UPDATE products
  SET stock_quantity = stock_quantity - ${OrderProcessRequest/quantity}
  WHERE product_id = '${OrderProcessRequest/productId}'

  -- SQL #3: 포인트 적립
  UPDATE customer_points
  SET point_balance = point_balance + ${OrderProcessRequest/earnedPoints}
  WHERE customer_id = '${OrderProcessRequest/customerId}'

요청 메시지: OrderProcessRequest
  - orderId: STRING
  - customerId: STRING
  - productId: STRING
  - quantity: INT
  - unitPrice: LONG
  - totalAmount: LONG
  - earnedPoints: INT