Coverage for functions \ flipdare \ service \ payments \ _payment_charge_handler.py: 9%

1#!/usr/bin/env python 

2# Copyright (c) 2026 Flipdare Pty Ltd. All rights reserved. 

3# 

4# This file is part of Flipdare's proprietary software and contains 

5# confidential and copyrighted material. Unauthorised copying, 

6# modification, distribution, or use of this file is strictly 

7# prohibited without prior written permission from Flipdare Pty Ltd. 

8# 

9# This software includes third-party components licensed under MIT, 

10# BSD, and Apache 2.0 licences. See THIRD_PARTY_NOTICES for details. 

11# 

12 

13from __future__ import annotations 

14from typing import TYPE_CHECKING, Any, Literal 

15from firebase_functions import https_fn 

16from flipdare.app_log import LOG 

17from flipdare.constants import IS_DEBUG, PAYMENT_MAX_INFO_RETRIES, PAYMENT_MAX_RETRIES 

18from flipdare.generated import ( 

19 PaymentCreateResponseSchema, 

20 PledgeModel, 

21 PaymentEventStatus, 

22 AppPaymentErrorCode, 

23 PaymentConfirmResponseSchema, 

24 ErrorSchema, 

25 AuditInfoModel, 

26 PaymentEventModel, 

27 PaymentModel, 

28) 

29from flipdare.generated.model.payment.payment_result_model import PaymentResultModel 

30from flipdare.generated.shared.payment.payment_status import PaymentStatus 

31from flipdare.generated.shared.stripe.stripe_intent_status import StripeIntentStatus 

32from flipdare.payments.data.app_payment_context import AppPaymentContext 

33from flipdare.payments.data.payment_event_context import PaymentEventContext 

34from flipdare.payments.data.payment_schedule import PaymentSchedule 

35from flipdare.payments.data.payment_validator import PaymentValidator 

36from flipdare.payments.dto.payment_intent_dto import PaymentIntentDTO 

37from flipdare.payments.payment_types import AccountRiskInfo 

38from flipdare.payments.app_stripe_proxy import AppStripeProxy 

39from flipdare.error import ( 

40 AppError, 

41 StripeErrorContext, 

42) 

43from flipdare.result.app_result import AppResult 

44from flipdare.result.job_result import JobResult 

45from flipdare.service._error_mixin import ErrorMixin 

46from flipdare.request import ( 

47 AppRequest, 

48 PaymentConfirmRequestAdapter, 

49 PaymentCreateRequestAdapter, 

50) 

51from flipdare.service._service_provider import ServiceProvider 

52from flipdare.service._user_mixin import UserMixin 

53from flipdare.service.payments._base_payment_handler import BasePaymentHandler 

54from flipdare.wrapper.payment.payment_event_wrapper import PaymentEventWrapper 

55from flipdare.wrapper.payment.pledge_wrapper import PledgeWrapper 

56from flipdare.wrapper.user_wrapper import UserWrapper 

57from flipdare.payments.core.stripe_guard import StripeGuard 

58from flipdare.util.slug_coder import SlugCoder 

59 

60if TYPE_CHECKING: 

61 from flipdare.manager.service_manager import ServiceManager 

62 from flipdare.service.payments._payment_account_handler import PaymentAccountHandler 

63 from flipdare.manager.backend_manager import BackendManager 

64 from flipdare.manager.db_manager import DbManager 

65 

66__all__ = ["PaymentChargeHandler"] 

67 

68 

69class PaymentChargeHandler(BasePaymentHandler, ErrorMixin, UserMixin, ServiceProvider): 

70 def __init__( 

71 self, 

72 proxy: AppStripeProxy, 

73 account_handler: PaymentAccountHandler, 

74 db_manager: DbManager | None = None, 

75 backend_manager: BackendManager | None = None, 

76 service_manager: ServiceManager | None = None, 

77 ) -> None: 

78 self.proxy = proxy 

79 self.account_handler = account_handler 

80 

81 super().__init__( 

82 db_manager=db_manager, 

83 backend_manager=backend_manager, 

84 service_manager=service_manager, 

85 ) 

86 

87 # ======================================================================== 

88 # WEB METHODS 

89 # ======================================================================== 

90 

91 def callable_create_charge( 

92 self, 

93 req: https_fn.CallableRequest[Any], 

94 ) -> PaymentCreateResponseSchema | ErrorSchema: 

95 request = AppRequest.callable(req) 

96 endpoint = request.endpoint or "(internal)create_charge" 

97 adapter: PaymentCreateRequestAdapter | None = None 

98 try: 

99 adapter = PaymentCreateRequestAdapter.from_callable(req) 

100 adapter.validate() 

101 except AppError as e: 

102 msg = f"Create Charge Request validation error: {e}\n\tRequest: {request!s}" 

103 LOG().error(msg) 

104 error = StripeErrorContext.from_code( 

105 endpoint=endpoint, 

106 error_code=AppPaymentErrorCode.INVALID_REQUEST, 

107 cause=msg, 

108 error=e, 

109 ) 

110 return error.to_dict() 

111 

112 customer_uid = adapter.customer_uid 

113 cust_user: UserWrapper | None = None 

114 try: 

115 cust_user = self.get_user_by_id(endpoint=endpoint, uid=customer_uid) 

116 except Exception as e: 

117 msg = f"Failed to retrieve from user for uid={customer_uid}\n\tError:{e}" 

118 LOG().error(msg) 

119 error = StripeErrorContext.from_code( 

120 endpoint=endpoint, 

121 error_code=AppPaymentErrorCode.INVALID_USER, 

122 cause=msg, 

123 error=e, 

124 ) 

125 return error.to_dict() 

126 

127 account_uid = adapter.account_uid 

128 risk_info: AccountRiskInfo | None = None 

129 try: 

130 risk_info = self.get_account_risk(endpoint=endpoint, account_uid=account_uid) 

131 except Exception as e: 

132 msg = f"Failed to retrieve account risk info for uid={account_uid}\n\tError:{e}" 

133 LOG().error(msg) 

134 error = StripeErrorContext.from_code( 

135 endpoint=endpoint, 

136 error_code=AppPaymentErrorCode.INVALID_USER, 

137 cause=msg, 

138 error=e, 

139 ) 

140 return error.to_dict() 

141 

142 customer_id = adapter.customer_id 

143 currency_code = adapter.currency_code 

144 email = adapter.email 

145 name = adapter.name 

146 

147 audit_info = AuditInfoModel.create( 

148 endpoint=endpoint, 

149 uid=customer_uid, 

150 ip_address=adapter.ip_address, 

151 device_fingerprint=adapter.device_fingerprint, 

152 ) 

153 

154 if customer_id is None: 

155 try: 

156 customer_id = self.account_handler.create_customer( 

157 endpoint=endpoint, 

158 user=cust_user, 

159 alt_currency_code=currency_code, 

160 name=name, 

161 email=email, 

162 ) 

163 except Exception as e: 

164 msg = f"Failed to create stripe customer for payment creation for user {customer_uid}\n\tError:{e}" 

165 LOG().error(msg) 

166 error = StripeErrorContext.from_code( 

167 endpoint=endpoint, 

168 error_code=AppPaymentErrorCode.INVALID_USER, 

169 cause=msg, 

170 error=e, 

171 ) 

172 return error.to_dict() 

173 

174 pledge_amount = adapter.pledge_amount 

175 dare_id = adapter.dare_id 

176 try: 

177 ctx = self._build_payment_context( 

178 audit_info=audit_info, 

179 risk_info=risk_info, 

180 cust_user=cust_user, 

181 dare_id=dare_id, 

182 amount=pledge_amount, 

183 ) 

184 payment_response = self.proxy.create_payment_intent(endpoint, ctx) 

185 payment_intent_id = payment_response["payment_intent_id"] 

186 

187 self._create_pledge_in_db( 

188 ctx=ctx, 

189 payment_intent_id=payment_intent_id, 

190 ) 

191 return payment_response 

192 

193 except Exception as e: 

194 msg = f"Failed to create charge for user {customer_uid}\n\tError:{e}" 

195 LOG().error(msg) 

196 error = StripeErrorContext.from_code( 

197 endpoint=endpoint, 

198 error_code=AppPaymentErrorCode.PAYMENT_CREATE_FAILED, 

199 cause=msg, 

200 error=e, 

201 ) 

202 return error.to_dict() 

203 

204 def callable_confirm_charge( 

205 self, 

206 req: https_fn.CallableRequest[Any], 

207 ) -> PaymentConfirmResponseSchema | ErrorSchema: 

208 # save the payment method id so it can be charged later 

209 # when the user confirms the pledge in the app 

210 # NOTE: we no longer cancel the intent immediately. 

211 # NOTE: this is because the charge may need to be re-authorized later if the 

212 # NOTE: dare/voting takes longer than the payment intent authorization hold period. 

213 # NOTE: instead, we add a charge to the capture_charge_db 

214 # NOTE: so we can re-authorize, delay capture etc. 

215 

216 request = AppRequest.callable(req) 

217 endpoint = request.endpoint or "(internal)authorize_charge" 

218 

219 adapter: PaymentConfirmRequestAdapter | None = None 

220 try: 

221 adapter = PaymentConfirmRequestAdapter.from_callable(req) 

222 adapter.validate() 

223 except AppError as e: 

224 msg = f"Authorize Charge Request validation error: {e}\n\tRequest: {request!s}" 

225 LOG().error(msg) 

226 error = StripeErrorContext.from_code( 

227 endpoint=endpoint, 

228 error_code=AppPaymentErrorCode.INVALID_REQUEST, 

229 cause=msg, 

230 error=e, 

231 ) 

232 return error.to_dict() 

233 

234 customer_uid = adapter.customer_uid 

235 payment_intent_id = adapter.payment_intent_id 

236 payment_method_id: str | None = None 

237 debug_str = f"(payment_intent_id {payment_intent_id} for user {customer_uid})" 

238 

239 # get the payment method id from the payment_intent_id 

240 try: 

241 intent = self.proxy.get_payment_intent(endpoint, payment_intent_id) 

242 payment_method_id = intent.payment_method_id 

243 except Exception as e: 

244 msg = f"Failed to retrieve payment intent {debug_str}\n\tError:{e}" 

245 LOG().error(msg) 

246 error = StripeErrorContext.from_code( 

247 endpoint=endpoint, 

248 error_code=AppPaymentErrorCode.CHARGE_AUTHORIZE_FAILED, 

249 cause=msg, 

250 error=e, 

251 ) 

252 return error.to_dict() 

253 

254 if payment_method_id is None: 

255 msg = f"Payment intent {debug_str} has no payment method id, cannot authorize charge." 

256 LOG().error(msg) 

257 error = StripeErrorContext.from_code( 

258 endpoint=endpoint, 

259 error_code=AppPaymentErrorCode.CHARGE_AUTHORIZE_FAILED, 

260 cause=msg, 

261 ) 

262 return error.to_dict() 

263 

264 LOG().debug(f"Authorizing charge {debug_str} with payment method {payment_method_id}") 

265 pledge_amount = adapter.pledge_amount 

266 pledge_id = adapter.pledge_id 

267 

268 try: 

269 self._update_payment_method( 

270 endpoint=endpoint, 

271 pledge_id=pledge_id, 

272 payment_method_id=payment_method_id, 

273 ) 

274 return PaymentConfirmResponseSchema( 

275 uid=customer_uid, 

276 pledge_amount=pledge_amount, 

277 ) 

278 except Exception as e: 

279 msg = f"Failed to update charge {debug_str} and payment method {payment_method_id}\n\tError:{e}" 

280 LOG().error(msg) 

281 error = StripeErrorContext.from_code( 

282 endpoint=endpoint, 

283 error_code=AppPaymentErrorCode.CHARGE_AUTHORIZE_FAILED, 

284 cause=msg, 

285 error=e, 

286 ) 

287 return error.to_dict() 

288 

289 # ======================================================================== 

290 # CRON METHODS 

291 # ======================================================================== 

292 

293 def process_unprocessed_payment( # noqa: PLR0912, PLR0915 

294 self, 

295 pledge: PledgeWrapper, 

296 ) -> JobResult[PledgeWrapper]: 

297 # this is for payments in an error state, we try to re-process 

298 # and if that fails we fail 

299 doc_id = pledge.doc_id 

300 main_result = AppResult[PledgeWrapper]( 

301 doc_id=doc_id, task_name=f"Pledge unprocessed for {doc_id}" 

302 ) 

303 

304 if pledge.payment is None: 

305 msg = f"Pledge {pledge.doc_id} has no payment to process." 

306 LOG().error(msg) 

307 return self._build_job_result_error( 

308 endpoint="(internal)process_unprocessed_payment", 

309 main_result=main_result, 

310 error_code=AppPaymentErrorCode.PAYMENT_MISSING, 

311 message=msg, 

312 pledge=pledge, 

313 ) 

314 

315 payment_intent_id = pledge.payment.payment_intent_id 

316 endpoint = f"(internal) reauthorize_payment_intent {doc_id}/{payment_intent_id}" 

317 

318 if pledge.error_count >= PAYMENT_MAX_RETRIES: 

319 msg = ( 

320 f"Pledge {doc_id} exceeded max retries ({pledge.error_count}), marking as failed." 

321 ) 

322 pledge.payment_status = PaymentStatus.FAILED 

323 return self._build_job_result_error( 

324 endpoint=endpoint, 

325 error_code=AppPaymentErrorCode.PAYMENT_MAX_RETRIES_EXCEEDED, 

326 message=msg, 

327 pledge=pledge, 

328 main_result=main_result, 

329 ) 

330 

331 intent: PaymentIntentDTO | None = None 

332 try: 

333 intent = self.proxy.get_payment_intent( 

334 endpoint=endpoint, 

335 payment_intent_id=payment_intent_id, 

336 ) 

337 except Exception as err: 

338 msg = f"Failed to retrieve payment intent for reauthorization for {payment_intent_id}: {err}" 

339 return self._build_job_result_error( 

340 endpoint=endpoint, 

341 message=msg, 

342 pledge=pledge, 

343 main_result=main_result, 

344 ) 

345 

346 debug_msg = f"(pledge={doc_id}/payment_intent_id={payment_intent_id})" 

347 

348 validator_obj = self._create_validator(endpoint, pledge, intent, main_result) 

349 if isinstance(validator_obj, JobResult): 

350 return validator_obj 

351 

352 validator = validator_obj 

353 # first we check if we need reauthorize 

354 result: JobResult[PledgeWrapper] 

355 if validator.can_reauthorize: 

356 result = self.reauthorize_payment(pledge) 

357 if result.is_error: 

358 msg = f"Failed to reauthorize payment for {debug_msg} with error: {result.message}" 

359 LOG().error(msg) 

360 return result 

361 

362 # then check each state and try to process accordingly. 

363 if validator.needs_additional_info: 

364 # not much we can do here, we wait for the user to update their payment 

365 # method or whatever is required. 

366 additional_ct = pledge.additional_info_count 

367 if additional_ct >= PAYMENT_MAX_INFO_RETRIES: 

368 msg = f"Pledge {doc_id} exceeded max additional info retries ({additional_ct}), marking as failed." 

369 pledge.payment_status = PaymentStatus.FAILED 

370 return self._build_job_result_error( 

371 endpoint=endpoint, 

372 error_code=AppPaymentErrorCode.PAYMENT_MAX_INFO_RETRIES_EXCEEDED, 

373 message=msg, 

374 pledge=pledge, 

375 main_result=main_result, 

376 ) 

377 else: 

378 msg = f"Payment for {debug_msg} requires additional info, cannot process." 

379 pledge.additional_info_count += 1 

380 self._update_pledge(endpoint, pledge) 

381 LOG().info(msg) 

382 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

383 

384 if validator.needs_capture: 

385 result = self.capture_payment(pledge) 

386 if result.is_error: 

387 msg = f"Failed to capture payment for {debug_msg} with error: {result.message}" 

388 LOG().error(msg) 

389 return result 

390 elif validator.needs_refund: 

391 result = self.refund_payment(pledge) 

392 if result.is_error: 

393 msg = f"Failed to refund payment for {debug_msg} with error: {result.message}" 

394 LOG().error(msg) 

395 return result 

396 elif validator.needs_transfer: 

397 result = self.transfer_payment(pledge) 

398 if result.is_error: 

399 msg = f"Failed to transfer payment for {debug_msg} with error: {result.message}" 

400 LOG().error(msg) 

401 return result 

402 

403 # This is potentially a problem ... 

404 # NOTE: we need to monitor the logs for these type of errors. 

405 # NOTE: they will probably require support intervention to resolve. 

406 msg = f"Payment for {debug_msg} is in an unknown state, cannot process." 

407 LOG().error(msg) 

408 return self._build_job_result_error( 

409 endpoint=endpoint, 

410 error_code=AppPaymentErrorCode.UNKNOWN_CHARGE_STATE, 

411 message=msg, 

412 pledge=pledge, 

413 main_result=main_result, 

414 ) 

415 

416 def reauthorize_payment(self, pledge: PledgeWrapper) -> JobResult[PledgeWrapper]: 

417 doc_id = pledge.doc_id 

418 main_result = AppResult[PledgeWrapper]( 

419 doc_id=doc_id, task_name=f"Pledge reauthorize for {doc_id}" 

420 ) 

421 

422 if pledge.payment is None: 

423 msg = f"Pledge {pledge.doc_id} has no payment to process." 

424 LOG().error(msg) 

425 return self._build_job_result_error( 

426 endpoint="(internal)process_unprocessed_payment", 

427 main_result=main_result, 

428 error_code=AppPaymentErrorCode.PAYMENT_MISSING, 

429 message=msg, 

430 pledge=pledge, 

431 ) 

432 

433 payment_intent_id = pledge.payment.payment_intent_id 

434 endpoint = f"(internal) reauthorize_payment_intent {doc_id}/{payment_intent_id}" 

435 

436 intent: PaymentIntentDTO | None = None 

437 try: 

438 intent = self.proxy.get_payment_intent( 

439 endpoint=endpoint, 

440 payment_intent_id=payment_intent_id, 

441 ) 

442 except Exception as err: 

443 msg = f"Failed to retrieve payment intent for reauthorization for {payment_intent_id}: {err}" 

444 return self._build_job_result_error( 

445 endpoint=endpoint, 

446 message=msg, 

447 pledge=pledge, 

448 main_result=main_result, 

449 ) 

450 

451 validator_obj = self._create_validator(endpoint, pledge, intent, main_result) 

452 if isinstance(validator_obj, JobResult): 

453 return validator_obj 

454 

455 validator = validator_obj 

456 if not validator.can_reauthorize: 

457 msg = f"Payment intent for pledge {doc_id} does not need reauthorization, skipping." 

458 LOG().info(msg) 

459 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

460 

461 if not intent.nearing_timeout: 

462 msg = ( 

463 f"Payment intent {payment_intent_id} is not nearing timeout, cannot reauthorize yet." 

464 f"(intent_status={intent.intent_status}, event_status={intent.event_status})" 

465 ) 

466 LOG().warning(msg) 

467 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

468 

469 # we need to cancel the existing intent 

470 # and create a new one with the same details to reauthorize the charge. 

471 try: 

472 self.proxy.cancel_payment_intent( 

473 endpoint=endpoint, 

474 payment_intent_id=payment_intent_id, 

475 ) 

476 except Exception as err: 

477 msg = f"Failed to cancel payment intent for reauthorization for {payment_intent_id}: {err}" 

478 LOG().error(msg) 

479 

480 main_result.add_error( 

481 error_code=AppPaymentErrorCode.API_ERROR, 

482 message=msg, 

483 ) 

484 return JobResult.from_result( 

485 main_result, 

486 data=pledge.to_json_dict(), 

487 message=msg, 

488 ) 

489 

490 # if we get here we have a valid payment. 

491 payment = pledge.payment 

492 payment_method_id = payment.payment_method_id 

493 assert payment_method_id is not None # narrowing 

494 

495 amount = payment.amount 

496 customer_id = payment.customer_id 

497 rcpt_currency_code = payment.customer_currency_code 

498 account_id = payment.account_id 

499 

500 try: 

501 self.proxy.reauthorize_payment_intent( 

502 endpoint=endpoint, 

503 customer_id=customer_id, 

504 account_id=account_id, 

505 amount=amount, 

506 fee_type=payment.fee_type, 

507 payment_method_id=payment_method_id, 

508 rcpt_currency_code=rcpt_currency_code, 

509 ) 

510 return JobResult.ok( 

511 doc_id=doc_id, 

512 message=f"Successfully reauthorized payment intent for charge {doc_id}", 

513 ) 

514 except Exception as err: 

515 msg = f"Failed to create new payment intent for reauthorization for {payment_intent_id}: {err}" 

516 LOG().error(msg) 

517 main_result.add_error( 

518 error_code=AppPaymentErrorCode.INTENT_INVALID_DATA, 

519 message=msg, 

520 ) 

521 return JobResult.from_result( 

522 main_result, 

523 data=pledge.to_json_dict(), 

524 message=msg, 

525 ) 

526 

527 def capture_payment( 

528 self, 

529 pledge: PledgeWrapper, 

530 ) -> JobResult[PledgeWrapper]: 

531 doc_id = pledge.doc_id 

532 payment = pledge.payment 

533 main_result = AppResult[PledgeWrapper]( 

534 doc_id=doc_id, task_name=f"Pledge capture for {doc_id}" 

535 ) 

536 

537 if payment is None: 

538 msg = f"Pledge {doc_id} has no payment to process." 

539 LOG().error(msg) 

540 return self._build_job_result_error( 

541 endpoint="(internal)process_unprocessed_payment", 

542 main_result=main_result, 

543 error_code=AppPaymentErrorCode.PAYMENT_MISSING, 

544 message=msg, 

545 pledge=pledge, 

546 ) 

547 

548 payment_intent_id = payment.payment_intent_id 

549 endpoint = f"(internal) capture_payment {doc_id}/{payment_intent_id}" 

550 

551 intent: PaymentIntentDTO | None = None 

552 try: 

553 intent = self.proxy.get_payment_intent( 

554 endpoint=endpoint, 

555 payment_intent_id=payment_intent_id, 

556 ) 

557 except Exception as err: 

558 msg = f"Failed to retrieve payment intent for capture for {payment_intent_id}: {err}" 

559 return self._build_job_result_error( 

560 endpoint=endpoint, 

561 message=msg, 

562 pledge=pledge, 

563 main_result=main_result, 

564 ) 

565 

566 validator_obj = self._create_validator(endpoint, pledge, intent, main_result) 

567 if isinstance(validator_obj, JobResult): 

568 return validator_obj 

569 

570 validator = validator_obj 

571 if not validator.needs_capture: 

572 msg = f"Payment intent for pledge {doc_id} cannot be captured, skipping." 

573 LOG().info(msg) 

574 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

575 

576 payment_intent_id = payment.payment_intent_id 

577 account_id = payment.account_id 

578 

579 debug_msg = f"(acct_id={account_id}/pm_id={payment_intent_id})" 

580 

581 try: 

582 intent = self.proxy.CAPTURE_PAYMENT( 

583 endpoint=endpoint, 

584 payment_intent_id=payment_intent_id, 

585 ) 

586 except Exception as e: 

587 msg = f"Failed to charge for pledge {pledge.doc_id}: {debug_msg}\n\tError:{e}" 

588 LOG().error(msg) 

589 error = StripeErrorContext.from_code( 

590 endpoint=endpoint, 

591 error_code=AppPaymentErrorCode.PAYMENT_CAPTURE_FAILED, 

592 cause=msg, 

593 error=e, 

594 ) 

595 raise AppError.from_context(error) from e 

596 

597 intent_status = intent.intent_status 

598 payment_status = PaymentStatus.CAPTURE 

599 if intent_status == StripeIntentStatus.CANCELED: 

600 # mark as complete, we cant process any further.. 

601 payment_status = PaymentStatus.COMPLETE 

602 msg = f"Intent {payment_intent_id} was canceled, marking payment as COMPLETE. {debug_msg}" 

603 

604 if IS_DEBUG: 

605 LOG().debug(msg) 

606 

607 pledge.payment_status = payment_status 

608 self._update_pledge(endpoint, pledge) 

609 return JobResult.ok(doc_id=doc_id, msg=msg) 

610 

611 # process event 

612 event_status = intent.event_status 

613 charge_id = intent.latest_charge_id 

614 result = PaymentResultModel( 

615 amount_captured=intent.amount_captured or 0, 

616 stripe_fee_amount=intent.stripe_fee_amount or 0, 

617 app_fee_amount=intent.app_fee_amount or 0, 

618 ) 

619 

620 if intent_status == StripeIntentStatus.SUCCEEDED and charge_id is not None: 

621 msg = f"Intent {payment_intent_id} captured successfully. {debug_msg}" 

622 if IS_DEBUG: 

623 LOG().debug(msg) 

624 

625 return self._add_payment_success_event( 

626 endpoint=endpoint, 

627 message=msg, 

628 pledge=pledge, 

629 intent_status=intent_status, 

630 stripe_id=charge_id, 

631 result=result, 

632 payment_status=payment_status, 

633 success_type="captured", 

634 ) 

635 

636 # if we get here, the charge was not successful, 

637 # we need to log an error and add a payment event for the failed charge. 

638 validation_msg = intent.validate_capture() 

639 msg = ( 

640 f"Payment failed validation or incorrect status for {debug_msg}" 

641 f"\n\tValidation message = {validation_msg}" 

642 f"\n\tCharge ID: = {charge_id}" 

643 f"\n\tIntent status = {intent_status}" 

644 f"\n\tEvent status: = {event_status}" 

645 ) 

646 LOG().error(msg) 

647 

648 return self._add_payment_error_event( 

649 endpoint=endpoint, 

650 message=msg, 

651 pledge=pledge, 

652 payment_result=result, 

653 intent_status=intent_status, 

654 event_status=event_status, 

655 app_result=main_result, 

656 payment_status=payment_status, 

657 ) 

658 

659 def refund_payment( 

660 self, 

661 pledge: PledgeWrapper, 

662 ) -> JobResult[PledgeWrapper]: 

663 doc_id = pledge.doc_id 

664 payment = pledge.payment 

665 main_result = AppResult[PledgeWrapper]( 

666 doc_id=doc_id, task_name=f"Pledge refund for {doc_id}" 

667 ) 

668 

669 if payment is None: 

670 msg = f"Pledge {doc_id} has no payment to process." 

671 LOG().error(msg) 

672 return self._build_job_result_error( 

673 endpoint="(internal)refund_payment", 

674 main_result=main_result, 

675 error_code=AppPaymentErrorCode.PAYMENT_MISSING, 

676 message=msg, 

677 pledge=pledge, 

678 ) 

679 

680 payment_intent_id = payment.payment_intent_id 

681 

682 endpoint = f"(internal) refund_payment {doc_id}/{payment_intent_id}" 

683 main_result = AppResult[PledgeWrapper](doc_id=doc_id, task_name=f"{endpoint} for {doc_id}") 

684 

685 intent: PaymentIntentDTO | None = None 

686 try: 

687 intent = self.proxy.get_payment_intent( 

688 endpoint=endpoint, 

689 payment_intent_id=payment_intent_id, 

690 ) 

691 except Exception as err: 

692 msg = f"Failed to retrieve payment intent for refund for {payment_intent_id}: {err}" 

693 return self._build_job_result_error( 

694 endpoint=endpoint, 

695 message=msg, 

696 pledge=pledge, 

697 main_result=main_result, 

698 ) 

699 

700 validator_obj = self._create_validator(endpoint, pledge, intent, main_result) 

701 if isinstance(validator_obj, JobResult): 

702 return validator_obj 

703 

704 validator = validator_obj 

705 if not validator.needs_refund: 

706 msg = f"Payment intent for pledge {doc_id} cannot be refunded, skipping." 

707 LOG().info(msg) 

708 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

709 

710 events: list[PaymentEventWrapper] = [] 

711 try: 

712 events = self.pledge_db.get_payment_events(pledge.doc_id) 

713 except Exception as e: 

714 msg = f"Failed to get payment events for release for pledge {doc_id}: {e}" 

715 LOG().error(msg) 

716 main_result.add_error( 

717 error_code=AppPaymentErrorCode.API_ERROR, 

718 message=msg, 

719 ) 

720 return JobResult.from_result( 

721 main_result, 

722 data=pledge.to_json_dict(), 

723 message=msg, 

724 ) 

725 

726 evt_ctx = PaymentEventContext(amount=payment.amount, events=events) 

727 refund_amount = evt_ctx.refundable_amount 

728 if refund_amount <= 0: 

729 msg = f"Payment intent for pledge {doc_id} cannot be refunded because invalid amount ({refund_amount}), skipping." 

730 LOG().info(msg) 

731 return JobResult.skip_doc(doc_id=doc_id, message=msg) 

732 

733 # if we get here the payment needs to be refunded and the latest_charge_id is not None. 

734 account_id = payment.account_id 

735 

736 debug_msg = f"(acct_id={account_id}/pm_id={payment_intent_id})" 

737 

738 try: 

739 refund = self.proxy.REFUND_PAYMENT( 

740 endpoint=endpoint, 

741 customer_id=payment.customer_id, 

742 obj_id=pledge.dare_id, 

743 payment_intent_id=payment_intent_id, 

744 refund_amount=refund_amount, 

745 ) 

746 except Exception as e: 

747 msg = f"Failed to release payment for pledge {pledge.doc_id}: {debug_msg}\n\tError:{e}" 

748 LOG().error(msg) 

749 error = StripeErrorContext.from_code( 

750 endpoint=endpoint, 

751 error_code=AppPaymentErrorCode.TRANSFER_FAILED, 

752 cause=msg, 

753 error=e, 

754 ) 

755 raise AppError.from_context(error) from e 

756 

757 # if we get here the transfer was successful... 

758 result = PaymentResultModel( 

759 amount_refunded=refund.amount, 

760 ) 

761 

762 msg = f"Payment for pledge {doc_id} refunded successfully with refund {refund.id}/{refund.amount}" 

763 if IS_DEBUG: 

764 LOG().debug(msg) 

765 

766 return self._add_payment_success_event( 

767 endpoint=endpoint, 

768 message=msg, 

769 pledge=pledge, 

770 intent_status=StripeIntentStatus.SUCCEEDED, 

771 stripe_id=refund.id, 

772 result=result, 

773 payment_status=PaymentStatus.COMPLETE, 

774 success_type="refunded", 

775 ) 

776 

777 def transfer_payment( 

778 self, 

779 pledge: PledgeWrapper, 

780 ) -> JobResult[PledgeWrapper]: 

781 payment = pledge.payment 

782 if payment is None: 

783 msg = f"Pledge {pledge.doc_id} has no payment information, cannot transfer." 

784 LOG().error(msg) 

785 return self._build_job_result_error( 

786 endpoint="(internal) transfer_payment", 

787 message=msg, 

788 pledge=pledge, 

789 main_result=AppResult[PledgeWrapper]( 

790 doc_id=pledge.doc_id, task_name="transfer_payment" 

791 ), 

792 ) 

793 

794 doc_id = pledge.doc_id 

795 payment_intent_id = payment.payment_intent_id 

796 

797 endpoint = f"(internal) transfer_payment {doc_id}/{payment_intent_id}" 

798 main_result = AppResult[PledgeWrapper](doc_id=doc_id, task_name=f"{endpoint} for {doc_id}") 

799 

800 intent: PaymentIntentDTO | None = None 

801 try: 

802 intent = self.proxy.get_payment_intent( 

803 endpoint=endpoint, 

804 payment_intent_id=payment_intent_id, 

805 ) 

806 except Exception as err: 

807 msg = f"Failed to retrieve payment intent for transfer for {payment_intent_id}: {err}" 

808 return self._build_job_result_error( 

809 endpoint=endpoint, 

810 message=msg, 

811 pledge=pledge, 

812 main_result=main_result, 

813 ) 

814