분리 승인

@app.post('/api/confirm')
def confirm_payment():
    data = request.get_json()
    receipt_id = data['receipt_id']
    order_id = data['order_id']
    order = Order.get(order_id)

    if not order or order.status != 'pending':
        return jsonify({'message': '승인할 수 없는 주문'}), 400

    if not check_inventory(order):
        return jsonify({'message': '재고가 부족해요.'}), 400

    confirmed = bootpay.confirm_payment(receipt_id)
    if confirmed['status'] != 1 or confirmed['price'] != order.price:
        return jsonify({'message': '결제 조회에 실패했어요.'}), 400

    order.update(status='done', bootpay_receipt_id=receipt_id)
    return jsonify({'success': True})python

$data = json_decode(file_get_contents('php://input'), true);
$receiptId = $data['receipt_id'];
$orderId = $data['order_id'];
$order = Order::find($orderId);

if (!$order || $order->status !== 'pending') {
    http_response_code(400);
    echo json_encode(['message' => '승인할 수 없는 주문']);
    exit;
}

if (!checkInventory($order)) {
    http_response_code(400);
    echo json_encode(['message' => '재고가 부족해요.']);
    exit;
}

$confirmed = BootpayApi::confirmPayment($receiptId);
if ($confirmed['status'] !== 1 || $confirmed['price'] !== $order->price) {
    http_response_code(400);
    echo json_encode(['message' => '결제 조회에 실패했어요.']);
    exit;
}

$order->update([
    'status' => 'done',
    'bootpay_receipt_id' => $receiptId,
]);

echo json_encode(['success' => true]);php

@PostMapping("/api/confirm")
public ResponseEntity<?> confirmPayment(@RequestBody ConfirmRequest body) throws Exception {
    var order = orderRepository.findById(body.orderId());
    if (order.isEmpty() || !"pending".equals(order.get().getStatus())) {
        return ResponseEntity.badRequest().body(Map.of("message", "승인할 수 없는 주문"));
    }

    if (!checkInventory(order.get())) {
        return ResponseEntity.badRequest().body(Map.of("message", "재고가 부족해요."));
    }

    var confirmed = bootpay.confirm(body.receiptId());
    int status = ((Number) confirmed.get("status")).intValue();
    double price = ((Number) confirmed.get("price")).doubleValue();

    if (status != 1 || price != order.get().getPrice()) {
        return ResponseEntity.badRequest().body(Map.of("message", "결제 조회에 실패했어요."));
    }

    order.get().setStatus("done");
    order.get().setBootpayReceiptId(body.receiptId());
    orderRepository.save(order.get());

    return ResponseEntity.ok(Map.of("success", true));
}java

post '/api/confirm' do
  payload = JSON.parse(request.body.read)
  receipt_id = payload['receipt_id']
  order = Order.find(payload['order_id'])

  halt 400, { message: '승인할 수 없는 주문' }.to_json unless order&.status == 'pending'
  halt 400, { message: '재고가 부족해요.' }.to_json unless check_inventory(order)

  confirmed = bootpay.confirm(receipt_id).data
  if confirmed['status'] != 1 || confirmed['price'] != order.price
    halt 400, { message: '결제 조회에 실패했어요.' }.to_json
  end

  order.update(status: 'done', bootpay_receipt_id: receipt_id)
  { success: true }.to_json
endruby

func confirmPayment(w http.ResponseWriter, r *http.Request) {
	var body struct {
		ReceiptID string `json:"receipt_id"`
		OrderID   string `json:"order_id"`
	}
	json.NewDecoder(r.Body).Decode(&body)

	order, err := findOrder(body.OrderID)
	if err != nil || order.Status != "pending" {
		http.Error(w, "승인할 수 없는 주문", http.StatusBadRequest)
		return
	}

	if !checkInventory(order) {
		http.Error(w, "재고가 부족해요.", http.StatusBadRequest)
		return
	}

	confirmed, err := api.ServerConfirm(body.ReceiptID)
	if err != nil {
		http.Error(w, "결제 조회에 실패했어요.", http.StatusBadRequest)
		return
	}

	status := int(confirmed["status"].(float64))
	price := confirmed["price"].(float64)
	if status != 1 || price != order.Price {
		http.Error(w, "결제 조회에 실패했어요.", http.StatusBadRequest)
		return
	}

	markOrderDone(body.OrderID, body.ReceiptID)
	json.NewEncoder(w).Encode(map[string]bool{"success": true})
}go

[HttpPost("/api/confirm")]
public async Task<IActionResult> ConfirmPayment([FromBody] ConfirmRequest body)
{
    var order = await orderRepository.FindAsync(body.OrderId);
    if (order == null || order.Status != "pending") {
        return BadRequest(new { Message = "승인할 수 없는 주문" });
    }

    if (!CheckInventory(order)) {
        return BadRequest(new { Message = "재고가 부족해요." });
    }

    var response = await bootpay.Confirm(body.ReceiptId);
    var confirmed = JsonConvert.DeserializeObject<Dictionary<string, object>>(
        await response.Content.ReadAsStringAsync()
    );

    if (Convert.ToInt32(confirmed["status"]) != 1 || Convert.ToDecimal(confirmed["price"]) != order.Price) {
        return BadRequest(new { Message = "결제 조회에 실패했어요." });
    }

    order.Status = "done";
    order.BootpayReceiptId = body.ReceiptId;
    await orderRepository.SaveAsync(order);

    return Ok(new { Success = true });
}csharp

app.post('/api/payment/confirm-check', async (req, res) => {
    const { receipt_id, order_id } = req.body

    const order = await db.orders.findById(order_id)
    if (!order || order.status !== 'pending') {
        return res.json({ can_confirm: false, message: '승인할 수 없는 주문' })
    }

    if (!checkInventory(order)) {
        return res.json({ can_confirm: false, message: '재고가 부족해요.' })
    }

    // 서버 승인 API를 호출하지 않아요.
    // 여기서는 DB에 저장해 둔 주문 금액·상태·재고 기준으로 승인 가능 여부만 판단해요.
    await db.paymentAttempts.create({
        order_id,
        bootpay_receipt_id: receipt_id,
        status: 'CONFIRM_CHECKED'
    })

    return res.json({ can_confirm: true })
})

app.post('/api/payment/complete', async (req, res) => {
    const { receipt_id, order_id } = req.body

    // Bootpay.confirm() 이후에도 클라이언트 응답만으로 주문을 확정하면 안 돼요.
    // 서버에서 receipt_id로 결제 정보를 다시 조회하고 DB 주문 금액·상태와 비교해야 해요.
    const payment = await verifyPayment(receipt_id)
    const order = await db.orders.findById(order_id)

    if (!order || payment.status !== 1 || payment.price !== order.price) {
        return res.status(400).json({ message: '결제 조회에 실패했어요.' })
    }

    await db.orders.update(
        { status: 'done', bootpay_receipt_id: receipt_id },
        { where: { id: order_id } }
    )

    return res.json({ success: true })
})javascript