Stripe Terminal

┌─────────────┐     ┌──────────────┐     ┌──────────────┐
│  클라이언트   │────▶│   백엔드 서버  │────▶│  Stripe API  │
│ (키오스크 앱) │◀────│              │◀────│              │
└──────┬──────┘     └──────────────┘     └──────────────┘
       │
       ▼
┌─────────────┐
│  카드 리더기  │
│ (Stripe 인증)│
└─────────────┘

// stripe-client.service.ts
async createPaymentIntent(params: {
  amount: number;
  currency: string;
  sessionId: string;
}) {
  const paymentIntent = await this.stripe.paymentIntents.create({
    amount: params.amount,
    currency: params.currency.toLowerCase(),
    payment_method_types: ['card_present'],
    capture_method: 'automatic',
    metadata: {
      sessionId: params.sessionId,
    },
  });

  return {
    id: paymentIntent.id,
    clientSecret: paymentIntent.client_secret,
  };
}

// 백엔드: Connection Token 발급 엔드포인트
@Post('stripe/connection-token')
async createConnectionToken() {
  const token = await this.stripe.terminal.connectionTokens.create();
  return { secret: token.secret };
}

const config = {
  onFetchConnectionToken: async () => {
    const response = await api.createStripeConnectionToken();
    return response.data.secret;
  },
  onUnexpectedReaderDisconnect: () => {
    // 리더기가 예기치 않게 연결 해제됐을 때 처리
    handleDisconnect();
  },
};

const terminal = StripeTerminal.create(config);

const { discoveredReaders, error } = await terminal.discoverReaders({
  simulated: false,
  location: 'tml_xxx', // Stripe Location ID
});

const { reader, error } = await terminal.connectReader(discoveredReaders[0]);

await terminal.disconnectReader();

const collectResult = await terminal.collectPaymentMethod(clientSecret);

const processResult = await terminal.processPayment(
  collectResult.paymentIntent,
);

async requestPayment(request: PaymentRequest): Promise<PaymentResult> {
  const terminal = await this.ensureTerminal();

  if (!this.reader) {
    await this.connect();
  }

  // 1. 카드 수집 대기
  this.emitStatus('waiting_card');
  const collectResult = await terminal.collectPaymentMethod(
    request.clientSecret,
  );

  if (collectResult.error) {
    this.emitStatus('failed');
    return { success: false, message: collectResult.error.message };
  }

  // 2. 결제 처리 (승인 요청)
  this.emitStatus('processing');
  const processResult = await terminal.processPayment(
    collectResult.paymentIntent,
  );

  if (processResult.error) {
    this.emitStatus('failed');
    return { success: false, message: processResult.error.message };
  }

  // 3. 결과 반환
  const intent = processResult.paymentIntent;
  const charge = intent.charges?.data?.[0];
  const cardPresent = charge?.payment_method_details?.card_present;

  return {
    success: intent.status === 'succeeded',
    gateway: 'stripe',
    paymentIntentId: intent.id,
    cardBrand: cardPresent?.brand,
    last4: cardPresent?.last4,
    receiptUrl: charge?.receipt_url,
  };
}

async complete(context: CompletePaymentContext): Promise<CompletePaymentResult> {
  const { payment, dto } = context;

  // 1. 클라이언트가 보낸 ID와 서버에 저장된 ID가 일치하는지 확인
  if (dto.paymentIntentId !== payment.externalPaymentId) {
    throw new BadRequestException('PaymentIntent ID mismatch');
  }

  // 2. Stripe API에서 직접 PaymentIntent 상태 조회
  const paymentIntent = await this.stripeClient.retrievePaymentIntent(
    dto.paymentIntentId,
  );

  const isSuccess = paymentIntent.status === 'succeeded';

  return {
    success: isSuccess,
    externalPaymentId: paymentIntent.id,
    receiptData: isSuccess ? this.extractReceiptData(paymentIntent) : undefined,
  };
}

// 시뮬레이터 활성화
const discoverParams = {
  simulated: true, // 실물 리더 대신 시뮬레이터 사용
};

// 테스트 카드 번호 설정
terminal.setSimulatorConfiguration({
  testCardNumber: '4242424242424242', // 성공하는 Visa 카드
});

// Stripe Dashboard 또는 API로 Location 생성
const location = await stripe.terminal.locations.create({
  display_name: '강남 1호점',
  address: {
    line1: '서울특별시 강남구 테헤란로 123',
    city: '서울',
    country: 'KR',
    postal_code: '06134',
  },
});
// location.id → 'tml_xxx'

const { discoveredReaders } = await terminal.discoverReaders({
  simulated: false,
  location: 'tml_xxx', // 이 위치의 리더만 검색
});

type PaymentStatus =
  | 'idle'          // 대기 중
  | 'connecting'    // 리더 연결 중
  | 'waiting_card'  // 카드 대기 중
  | 'processing'    // 결제 처리 중
  | 'success'       // 성공
  | 'failed'        // 실패
  | 'cancelled';    // 취소됨

class StripeGateway implements PaymentGateway {
  private statusCallback: ((status: PaymentStatus) => void) | null = null;

  onStatusChange(callback: (status: PaymentStatus) => void): void {
    this.statusCallback = callback;
  }

  private emitStatus(status: PaymentStatus): void {
    this.statusCallback?.(status);
  }
}

// 리더 검색 실패
const { error, discoveredReaders } = await terminal.discoverReaders(params);
if (error || !discoveredReaders?.length) {
  // 네트워크 확인 → Location ID 확인 → 리더 전원 확인
  throw new Error('리더를 찾을 수 없습니다.');
}

// 리더 연결 실패
const connectResult = await terminal.connectReader(reader);
if (connectResult.error) {
  // 리더가 다른 세션에 이미 연결되어 있을 수 있음
  // → 기존 연결 해제 후 재시도
  throw new Error(connectResult.error.message);
}

// 카드 수집 실패
const collectResult = await terminal.collectPaymentMethod(clientSecret);
if (collectResult.error) {
  // 카드 읽기 실패, 타임아웃, 취소 등
  // → 사용자에게 재시도 안내
}

// 결제 처리 실패
const processResult = await terminal.processPayment(paymentIntent);
if (processResult.error) {
  // 카드 거절, 잔액 부족 등
  // → 다른 카드로 재시도 안내
}

async connect(): Promise<void> {
  // 이미 연결된 리더가 있으면 먼저 해제 (재시도 시나리오)
  if (this.reader) {
    await this.disconnect();
  }
  // ... 새로 연결
}