Coverage for functions \ flipdare \ wrapper \ payment \ pledge_wrapper.py: 62%

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 

14 

15from flipdare.generated.model.payment.audit_info_model import AuditInfoModel 

16from flipdare.generated.model.payment.customer_info_model import CustomerInfoModel 

17from flipdare.generated.model.payment.payment_event_model import PaymentEventModel 

18from flipdare.generated.model.payment.payment_model import PaymentModel 

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

20from flipdare.generated.model.payment.payment_schedule_model import PaymentScheduleModel 

21from flipdare.generated.model.payment.pledge_model import PledgeKeys, PledgeModel 

22from flipdare.generated.model.payment.risk_assessment_model import RiskAssessmentModel 

23from flipdare.generated.shared.model.pledge_status import PledgeStatus 

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

25from flipdare.generated.shared.stripe.stripe_currency_code import StripeCurrencyCode 

26from flipdare.wrapper._persisted_wrapper import PersistedWrapper 

27 

28__all__ = ["PledgeWrapper"] 

29 

30_K = PledgeKeys 

31 

32 

33class PledgeWrapper(PersistedWrapper[PledgeModel]): 

34 MODEL_CLASS = PledgeModel 

35 

36 # ---- Properties ----------------------------------------- 

37 

38 @property 

39 def from_uid(self) -> str: 

40 return self._model.from_uid 

41 

42 @from_uid.setter 

43 def from_uid(self, value: str) -> None: 

44 self.update_field(_K.FROM_UID, value) 

45 

46 @property 

47 def to_uid(self) -> str | None: 

48 return self._model.to_uid 

49 

50 @to_uid.setter 

51 def to_uid(self, value: str | None) -> None: 

52 self.update_field(_K.TO_UID, value) 

53 

54 @property 

55 def dare_id(self) -> str: 

56 return self._model.dare_id 

57 

58 @dare_id.setter 

59 def dare_id(self, value: str) -> None: 

60 self.update_field(_K.DARE_ID, value) 

61 

62 @property 

63 def gid(self) -> str | None: 

64 return self._model.gid 

65 

66 @gid.setter 

67 def gid(self, value: str | None) -> None: 

68 self.update_field(_K.GID, value) 

69 

70 @property 

71 def amount(self) -> int: 

72 return self._model.amount 

73 

74 @property 

75 def currency_code(self) -> StripeCurrencyCode: 

76 return self._model.currency_code 

77 

78 @property 

79 def status(self) -> PledgeStatus: 

80 return self._model.status 

81 

82 @status.setter 

83 def status(self, value: PledgeStatus) -> None: 

84 self.update_field(_K.STATUS, value) 

85 

86 @property 

87 def payment_event_count(self) -> int: 

88 return self._model.payment_event_ct 

89 

90 @payment_event_count.setter 

91 def payment_event_count(self, value: int) -> None: 

92 self.update_field(_K.PAYMENT_EVENT_CT, value) 

93 

94 # ---- nested properties ----------------------------------------- 

95 

96 @property 

97 def payment(self) -> PaymentModel | None: 

98 return self._model.payment 

99 

100 @payment.setter 

101 def payment(self, value: PaymentModel) -> None: 

102 self.update_field(_K.PAYMENT, value) 

103 

104 @property 

105 def payment_status(self) -> PaymentStatus | None: 

106 return self._model.payment.status if self._model.payment else None 

107 

108 @payment_status.setter 

109 def payment_status(self, value: PaymentStatus) -> None: 

110 payment = self._model.payment 

111 if payment is None: 

112 raise ValueError("Cannot set payment status when payment is None") 

113 

114 payment.status = value 

115 self.update_field(_K.PAYMENT, payment) 

116 

117 @property 

118 def customer_info(self) -> CustomerInfoModel | None: 

119 if self.payment is None: 

120 return None 

121 

122 return self.payment.customer_info 

123 

124 @property 

125 def audit_info(self) -> AuditInfoModel | None: 

126 if self.payment is None: 

127 return None 

128 

129 return self.payment.audit_info 

130 

131 @property 

132 def risk_assessment(self) -> RiskAssessmentModel | None: 

133 if self.payment is None: 

134 return None 

135 

136 return self.payment.risk_assessment 

137 

138 @property 

139 def payment_method_id(self) -> str | None: 

140 if self.payment is None: 

141 return None 

142 

143 return self.payment.payment_method_id 

144 

145 @payment_method_id.setter 

146 def payment_method_id(self, payment_method_id: str) -> None: 

147 payment = self._model.payment 

148 if payment is None: 

149 raise ValueError("Cannot set payment method ID when payment is None") 

150 

151 payment.payment_method_id = payment_method_id 

152 self.update_field(_K.PAYMENT, payment) 

153 

154 @property 

155 def last_payment_event(self) -> PaymentEventModel | None: 

156 return self._model.payment.last_event if self._model.payment else None 

157 

158 @last_payment_event.setter 

159 def last_payment_event(self, value: PaymentEventModel | None) -> None: 

160 payment = self._model.payment 

161 if payment is None: 

162 raise ValueError("Cannot set last payment event when payment is None") 

163 

164 payment.last_event = value 

165 self.update_field(_K.PAYMENT, payment) 

166 

167 def update_payment_result(self, result: PaymentResultModel) -> None: 

168 payment = self._model.payment 

169 if payment is None: 

170 raise ValueError("Cannot update payment result when payment is None") 

171 

172 payment.result_total.accumulate(result) 

173 self.update_field(_K.PAYMENT, payment) 

174 

175 @property 

176 def payment_schedule(self) -> PaymentScheduleModel | None: 

177 return self._model.payment.schedule if self._model.payment else None 

178 

179 @payment_schedule.setter 

180 def payment_schedule(self, value: PaymentScheduleModel) -> None: 

181 payment = self._model.payment 

182 if payment is None: 

183 raise ValueError("Cannot set payment schedule when payment is None") 

184 

185 payment.schedule = value 

186 self.update_field(_K.PAYMENT, payment) 

187 

188 # ---- base internal fields ----------------------------------------- 

189 

190 @property 

191 def version(self) -> int: 

192 return self._model.version 

193 

194 @version.setter 

195 def version(self, value: int) -> None: 

196 self.update_field(_K.VERSION, value) 

197 

198 @property 

199 def processed(self) -> bool: 

200 return self._model.processed 

201 

202 @processed.setter 

203 def processed(self, value: bool) -> None: 

204 self.update_field(_K.PROCESSED, value) 

205 

206 @property 

207 def error_count(self) -> int: 

208 return self._model.error_count 

209 

210 @error_count.setter 

211 def error_count(self, value: int) -> None: 

212 self.update_field(_K.ERROR_COUNT, value) 

213 

214 @property 

215 def additional_info_count(self) -> int: 

216 return self._model.additional_info_count 

217 

218 @additional_info_count.setter 

219 def additional_info_count(self, value: int) -> None: 

220 self.update_field(_K.ADDITIONAL_INFO_COUNT, value) 

221 

222 # ---- pledge internal fields ----------------------------------------- 

223 

224 @property 

225 def notified_processing(self) -> bool: 

226 return self._model.notified_processing 

227 

228 @notified_processing.setter 

229 def notified_processing(self, value: bool) -> None: 

230 self.update_field(_K.NOTIFIED_PROCESSING, value) 

231 

232 @property 

233 def notified_processed(self) -> bool: 

234 return self._model.notified_processed 

235 

236 @notified_processed.setter 

237 def notified_processed(self, value: bool) -> None: 

238 self.update_field(_K.NOTIFIED_PROCESSED, value) 

239 

240 # </AUTO_GENERATED_CONTENT> - do not edit