Skip to content

Model brokers

components.payment_gateway.subcomponents.cards.models.brokers.card

CardModelBroker

Bases: BaseModelBroker

autoload class-attribute instance-attribute 

autoload = {'current_status_log': True}

create_card classmethod 

create_card(
    session,
    /,
    *,
    provider,
    external_id,
    display_name,
    expiration_date,
    last_four_digits,
    is_virtual,
    description=None,
    reference=None,
    issued_at=None,
    issuance_reason=None,
    id=None,
    card_holder_id=None,
    account_id=None,
    status=CardStatus.inactive,
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
@classmethod
def create_card(
    cls,
    session: Session,
    /,
    *,
    provider: PaymentServiceProvider,
    external_id: str,
    display_name: str,
    expiration_date: date,
    last_four_digits: str,
    is_virtual: bool,
    description: str | None = None,
    reference: str | None = None,
    issued_at: datetime | None = None,
    issuance_reason: str | None = None,
    id: UUID | None = None,
    card_holder_id: UUID | None = None,
    account_id: UUID | None = None,
    status: CardStatus = CardStatus.inactive,
) -> Card:
    card = cls.model(
        id=id,
        provider=provider,
        external_id=external_id,
        display_name=display_name,
        expiration_date=expiration_date,
        last_four_digits=last_four_digits,
        is_virtual=is_virtual,
        description=description,
        reference=reference,
        issued_at=issued_at,
        issuance_reason=issuance_reason,
        card_holder_id=card_holder_id,
        account_id=account_id,
    )
    status_log = CardStatusLog(card=card, status=status)
    session.add(card)
    session.add(status_log)
    session.flush()

    return card

get_card classmethod 

get_card(session, /, id, with_status_history=False)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@classmethod
def get_card(
    cls,
    session: Session,
    /,
    id: UUID,
    with_status_history: bool = False,
) -> Card:
    if with_status_history:
        query = cls.select(custom_autoload=cls.autoload | {"status_history": True})
    else:
        query = cls.select()
    card: Card = session.execute(query.filter(Card.id == id)).scalar_one()
    return card

get_card_by_external_id classmethod 

get_card_by_external_id(session, /, provider, external_id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
67
@classmethod
def get_card_by_external_id(
    cls,
    session: Session,
    /,
    provider: PaymentServiceProvider,
    external_id: str,
) -> Card:
    card: Card = session.execute(
        cls.select().filter(
            Card.provider == provider, Card.external_id == external_id
        )
    ).scalar_one()
    return card

get_card_id_by_external_id classmethod 

get_card_id_by_external_id(
    session, /, provider, external_id
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@classmethod
def get_card_id_by_external_id(
    cls,
    session: Session,
    /,
    provider: PaymentServiceProvider,
    external_id: str,
) -> UUID:
    card: Card = session.execute(
        cls.select(custom_autoload={})
        .filter(Card.provider == provider, Card.external_id == external_id)
        .options(load_only(Card.id))
    ).scalar_one()
    return card.id

list_card_ids_for_account classmethod 

list_card_ids_for_account(
    session, /, account_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@classmethod
def list_card_ids_for_account(
    cls,
    session: Session,
    /,
    account_id: UUID,
    with_terminated: bool = False,
) -> list[UUID]:
    query = (
        cls.select(custom_autoload={})
        .filter(Card.account_id == account_id)
        .options(load_only(Card.id))
    )
    if not with_terminated:
        query = query.filter(Card.terminated_at.is_(None))
    cards = session.execute(query).scalars().all()
    return [card.id for card in cards]

list_card_ids_for_card_holder classmethod 

list_card_ids_for_card_holder(
    session, /, card_holder_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
@classmethod
def list_card_ids_for_card_holder(
    cls,
    session: Session,
    /,
    card_holder_id: UUID,
    with_terminated: bool = False,
) -> list[UUID]:
    query = (
        cls.select(custom_autoload={})
        .filter(Card.card_holder_id == card_holder_id)
        .options(load_only(Card.id))
    )
    if not with_terminated:
        query = query.filter(Card.terminated_at.is_(None))
    cards = session.execute(query).scalars().all()
    return [card.id for card in cards]

list_cards_for_account classmethod 

list_cards_for_account(
    session, /, account_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
118
119
120
121
122
123
124
125
126
127
128
129
@classmethod
def list_cards_for_account(
    cls,
    session: Session,
    /,
    account_id: UUID,
    with_terminated: bool = False,
) -> list[Card]:
    query = cls.select().filter(Card.account_id == account_id)
    if not with_terminated:
        query = query.filter(Card.terminated_at.is_(None))
    return list(session.execute(query).scalars().all())

list_cards_for_card_holder classmethod 

list_cards_for_card_holder(
    session, /, card_holder_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
87
88
89
90
91
92
93
94
95
96
97
98
@classmethod
def list_cards_for_card_holder(
    cls,
    session: Session,
    /,
    card_holder_id: UUID,
    with_terminated: bool = False,
) -> list[Card]:
    query = cls.select().filter(Card.card_holder_id == card_holder_id)
    if not with_terminated:
        query = query.filter(Card.terminated_at.is_(None))
    return list(session.execute(query).scalars().all())

model class-attribute instance-attribute 

model = Card

set_card_status classmethod 

set_card_status(
    session,
    /,
    id,
    status,
    reason=None,
    suspension_source=None,
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
@classmethod
def set_card_status(
    cls,
    session: Session,
    /,
    id: UUID,
    status: CardStatus,
    reason: str | None = None,
    suspension_source: CardSuspensionSource | None = None,
) -> None:
    card = cls.get_card(session, id)
    if card.status == status:
        return
    status_log = CardStatusLog(
        card=card, status=status, reason=reason, suspension_source=suspension_source
    )
    session.add(status_log)
    session.refresh(card)

terminate_card classmethod 

terminate_card(session, /, id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card.py 
193
194
195
196
197
198
199
200
201
202
203
@classmethod
def terminate_card(
    cls,
    session: Session,
    /,
    id: UUID,
) -> Card:
    card = cls.get_card(session, id)
    card.terminated_at = datetime.now()

    return card

components.payment_gateway.subcomponents.cards.models.brokers.card_holder

CardHolderModelBroker

Bases: BaseModelBroker

create_card_holder classmethod 

create_card_holder(
    session,
    /,
    *,
    provider,
    external_id,
    first_name,
    last_name,
    display_name=None,
    short_name=None,
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_holder.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@classmethod
def create_card_holder(
    cls,
    session: Session,
    /,
    *,
    provider: PaymentServiceProvider,
    external_id: str | None,
    first_name: str,
    last_name: str,
    display_name: str | None = None,
    short_name: str | None = None,
) -> CardHolder:
    card_holder = cls.model(
        provider=provider,
        external_id=external_id,
        first_name=first_name,
        last_name=last_name,
        display_name=display_name,
        short_name=short_name,
    )
    session.add(card_holder)
    session.flush()

    return card_holder

get_card_holder classmethod 

get_card_holder(session, /, id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_holder.py 
22
23
24
25
26
27
28
29
30
31
32
@classmethod
def get_card_holder(
    cls,
    session: Session,
    /,
    id: UUID,
) -> CardHolder:
    card_holder: CardHolder = session.execute(
        cls.select().filter(CardHolder.id == id)
    ).scalar_one()
    return card_holder

get_card_holder_by_external_id classmethod 

get_card_holder_by_external_id(
    session, /, provider, external_id
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_holder.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@classmethod
def get_card_holder_by_external_id(
    cls,
    session: Session,
    /,
    provider: PaymentServiceProvider,
    external_id: str,
) -> CardHolder:
    card_holder: CardHolder = session.execute(
        cls.select().filter(
            CardHolder.provider == provider, CardHolder.external_id == external_id
        )
    ).scalar_one()
    return card_holder

model class-attribute instance-attribute 

model = CardHolder

terminate_card_holder classmethod 

terminate_card_holder(session, /, id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_holder.py 
88
89
90
91
92
93
94
95
96
97
98
@classmethod
def terminate_card_holder(
    cls,
    session: Session,
    /,
    id: UUID,
) -> CardHolder:
    card_holder = cls.get_card_holder(session, id)
    card_holder.terminated_at = datetime.now()

    return card_holder

update_card_holder classmethod 

update_card_holder(session, /, id, **data)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_holder.py 
75
76
77
78
79
80
81
82
83
84
85
86
@classmethod
def update_card_holder(
    cls,
    session: Session,
    /,
    id: UUID,
    **data: Unpack[CardHolderUpdate],
) -> CardHolder:
    card_holder = cls.get_card_holder(session, id)
    card_holder.assign(data)

    return card_holder

CardHolderUpdate

Bases: TypedDict

display_name instance-attribute 

display_name

first_name instance-attribute 

first_name

last_name instance-attribute 

last_name

short_name instance-attribute 

short_name

components.payment_gateway.subcomponents.cards.models.brokers.card_order

CardOrderModelBroker

Bases: BaseModelBroker

create_card_order classmethod 

create_card_order(
    session,
    /,
    *,
    card_id,
    delivery_status,
    shipping_method,
    tracking_number=None,
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_order.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
@classmethod
def create_card_order(
    cls,
    session: Session,
    /,
    *,
    card_id: UUID,
    delivery_status: CardDeliveryStatus,
    shipping_method: str,
    tracking_number: str | None = None,
) -> CardOrder:
    card_order = cls.model(
        card_id=card_id,
        delivery_status=delivery_status,
        shipping_method=shipping_method,
        tracking_number=tracking_number,
    )
    session.add(card_order)
    session.flush()

    return card_order

get_card_order classmethod 

get_card_order(session, /, id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_order.py 
17
18
19
20
21
22
23
24
25
26
27
@classmethod
def get_card_order(
    cls,
    session: Session,
    /,
    id: UUID,
) -> CardOrder:
    card_order: CardOrder = session.execute(
        cls.select().filter(CardOrder.id == id)
    ).scalar_one()
    return card_order

get_card_order_for_card classmethod 

get_card_order_for_card(session, /, card_id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_order.py 
29
30
31
32
33
34
35
36
37
38
39
@classmethod
def get_card_order_for_card(
    cls,
    session: Session,
    /,
    card_id: UUID,
) -> CardOrder:
    card_order: CardOrder = session.execute(
        cls.select().filter(CardOrder.card_id == card_id)
    ).scalar_one()
    return card_order

model class-attribute instance-attribute 

model = CardOrder

set_card_order_delivery_status classmethod 

set_card_order_delivery_status(
    session, /, id, delivery_status
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_order.py 
63
64
65
66
67
68
69
70
71
72
73
74
@classmethod
def set_card_order_delivery_status(
    cls,
    session: Session,
    /,
    id: UUID,
    delivery_status: CardDeliveryStatus,
) -> CardOrder:
    card_order = cls.get_card_order(session, id)
    card_order.delivery_status = delivery_status

    return card_order

set_card_order_tracking_number classmethod 

set_card_order_tracking_number(
    session, /, id, tracking_number
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_order.py 
76
77
78
79
80
81
82
83
84
85
86
87
@classmethod
def set_card_order_tracking_number(
    cls,
    session: Session,
    /,
    id: UUID,
    tracking_number: str,
) -> CardOrder:
    card_order = cls.get_card_order(session, id)
    card_order.tracking_number = tracking_number

    return card_order

components.payment_gateway.subcomponents.cards.models.brokers.card_provisioning

CardProvisioningModelBroker

Bases: BaseModelBroker

create_card_provisioning classmethod 

create_card_provisioning(
    session,
    /,
    *,
    provider,
    external_id,
    provisioning_type,
    provisioning_date,
    wallet_provider,
    card_id=None,
)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_provisioning.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
@classmethod
def create_card_provisioning(
    cls,
    session: Session,
    /,
    *,
    provider: PaymentServiceProvider,
    external_id: str,
    provisioning_type: ProvisioningType,
    provisioning_date: datetime,
    wallet_provider: str,
    card_id: UUID | None = None,
) -> CardProvisioning:
    card_provisioning = cls.model(
        provider=provider,
        external_id=external_id,
        provisioning_type=provisioning_type,
        provisioning_date=provisioning_date,
        wallet_provider=wallet_provider,
        card_id=card_id,
    )
    session.add(card_provisioning)
    session.flush()

    return card_provisioning

list_card_provisionings_for_card classmethod 

list_card_provisionings_for_card(session, /, card_id)
Source code in components/payment_gateway/subcomponents/cards/models/brokers/card_provisioning.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
@classmethod
def list_card_provisionings_for_card(
    cls,
    session: Session,
    /,
    card_id: UUID,
) -> list[CardProvisioning]:
    result = (
        session.execute(cls.select().filter(CardProvisioning.card_id == card_id))
        .scalars()
        .all()
    )
    return cast("list[CardProvisioning]", result)

model class-attribute instance-attribute 

model = CardProvisioning