Skip to content

Model brokers

components.payment_gateway.subcomponents.rules.models.brokers.expense_limit_rule

ExpenseLimitRuleModelBroker

Bases: BaseModelBroker

create_expense_limit_rule classmethod 

create_expense_limit_rule(
    session,
    /,
    *,
    external_id,
    description,
    reference,
    amount,
    currency,
    period,
    first_day=None,
    criteria,
    is_active,
    start=None,
    end=None,
    card_id=None,
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
@classmethod
def create_expense_limit_rule(
    cls,
    session: Session,
    /,
    *,
    external_id: str,
    description: str,
    reference: str,
    amount: int,
    currency: CurrencyCode,
    period: ExpenseLimitPeriod,
    first_day: int | None = None,
    criteria: list[RuleCriterion],
    is_active: bool,
    start: datetime | None = None,
    end: datetime | None = None,
    card_id: UUID | None = None,
) -> ExpenseLimitRule:
    expense_limit_rule = cls.model(
        description=description,
        reference=reference,
        amount=amount,
        currency=currency,
        period=period,
        first_day=first_day,
        criteria=criteria,
        is_active=is_active,
        start=start,
        end=end,
        external_id=external_id,
        card_id=card_id,
    )
    session.add(expense_limit_rule)
    session.flush()

    return expense_limit_rule

get_expense_limit_rule classmethod 

get_expense_limit_rule(session, /, id)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
31
32
33
34
35
36
37
38
39
40
41
@classmethod
def get_expense_limit_rule(
    cls,
    session: Session,
    /,
    id: UUID,
) -> ExpenseLimitRule:
    expense_limit_rule: ExpenseLimitRule = session.execute(
        cls.select().filter(ExpenseLimitRule.id == id)
    ).scalar_one()
    return expense_limit_rule

get_expense_limit_rule_id_by_external_id classmethod 

get_expense_limit_rule_id_by_external_id(
    session, /, external_id
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
@classmethod
def get_expense_limit_rule_id_by_external_id(
    cls,
    session: Session,
    /,
    external_id: str,
) -> UUID:
    expense_limit_rule: ExpenseLimitRule = session.execute(
        cls.select(custom_autoload={})
        .filter(ExpenseLimitRule.external_id == external_id)
        .options(load_only(ExpenseLimitRule.id))
    ).scalar_one()
    return expense_limit_rule.id

list_expense_limit_rule_ids_for_card classmethod 

list_expense_limit_rule_ids_for_card(
    session, /, card_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@classmethod
def list_expense_limit_rule_ids_for_card(
    cls,
    session: Session,
    /,
    card_id: UUID,
    with_terminated: bool = False,
) -> list[UUID]:
    query = (
        cls.select(custom_autoload={})
        .filter(ExpenseLimitRule.card_id == card_id)
        .options(load_only(ExpenseLimitRule.id))
    )
    if not with_terminated:
        query = query.filter(ExpenseLimitRule.terminated_at.is_(None))
    expense_limit_rules = session.execute(query).scalars().all()
    return [expense_limit_rule.id for expense_limit_rule in expense_limit_rules]

list_expense_limit_rules_for_card classmethod 

list_expense_limit_rules_for_card(
    session, /, card_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
75
76
77
78
79
80
81
82
83
84
85
86
@classmethod
def list_expense_limit_rules_for_card(
    cls,
    session: Session,
    /,
    card_id: UUID,
    with_terminated: bool = False,
) -> list[ExpenseLimitRule]:
    query = cls.select().filter(ExpenseLimitRule.card_id == card_id)
    if not with_terminated:
        query = query.filter(ExpenseLimitRule.terminated_at.is_(None))
    return list(session.execute(query).scalars().all())

model class-attribute instance-attribute 

model = ExpenseLimitRule

terminate_expense_limit_rule classmethod 

terminate_expense_limit_rule(session, /, id)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
139
140
141
142
143
144
145
146
147
148
149
@classmethod
def terminate_expense_limit_rule(
    cls,
    session: Session,
    /,
    id: UUID,
) -> ExpenseLimitRule:
    expense_limit_rule = cls.get_expense_limit_rule(session, id)
    expense_limit_rule.terminated_at = datetime.now()

    return expense_limit_rule

update_expense_limit_rule classmethod 

update_expense_limit_rule(session, /, id, **data)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/expense_limit_rule.py 
126
127
128
129
130
131
132
133
134
135
136
137
@classmethod
def update_expense_limit_rule(
    cls,
    session: Session,
    /,
    id: UUID,
    **data: Unpack[ExpenseLimitRuleUpdate],
) -> ExpenseLimitRule:
    expense_limit_rule = cls.get_expense_limit_rule(session, id)
    expense_limit_rule.assign(data)

    return expense_limit_rule

ExpenseLimitRuleUpdate

Bases: TypedDict

amount instance-attribute 

amount

criteria instance-attribute 

criteria

end instance-attribute 

end

is_active instance-attribute 

is_active

start instance-attribute 

start

components.payment_gateway.subcomponents.rules.models.brokers.usage_restriction_rule

UsageRestrictionRuleModelBroker

Bases: BaseModelBroker

create_usage_restriction_rule classmethod 

create_usage_restriction_rule(
    session,
    /,
    *,
    external_id,
    description,
    reference,
    criteria,
    is_active,
    start=None,
    end=None,
    account_id=None,
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@classmethod
def create_usage_restriction_rule(
    cls,
    session: Session,
    /,
    *,
    external_id: str,
    description: str,
    reference: str,
    criteria: list[RuleCriterion],
    is_active: bool,
    start: datetime | None = None,
    end: datetime | None = None,
    account_id: UUID | None = None,
) -> UsageRestrictionRule:
    usage_restriction_rule = cls.model(
        description=description,
        reference=reference,
        criteria=criteria,
        is_active=is_active,
        start=start,
        end=end,
        external_id=external_id,
        account_id=account_id,
    )
    session.add(usage_restriction_rule)
    session.flush()

    return usage_restriction_rule

get_usage_restriction_rule classmethod 

get_usage_restriction_rule(session, /, id)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
26
27
28
29
30
31
32
33
34
35
36
@classmethod
def get_usage_restriction_rule(
    cls,
    session: Session,
    /,
    id: UUID,
) -> UsageRestrictionRule:
    usage_restriction_rule: UsageRestrictionRule = session.execute(
        cls.select().filter(UsageRestrictionRule.id == id)
    ).scalar_one()
    return usage_restriction_rule

get_usage_restriction_rule_id_by_external_id classmethod 

get_usage_restriction_rule_id_by_external_id(
    session, /, external_id
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
@classmethod
def get_usage_restriction_rule_id_by_external_id(
    cls,
    session: Session,
    /,
    external_id: str,
) -> UUID:
    usage_restriction_rule: UsageRestrictionRule = session.execute(
        cls.select(custom_autoload={})
        .filter(UsageRestrictionRule.external_id == external_id)
        .options(load_only(UsageRestrictionRule.id))
    ).scalar_one()
    return usage_restriction_rule.id

list_usage_restriction_rule_ids_for_account classmethod 

list_usage_restriction_rule_ids_for_account(
    session, /, account_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
@classmethod
def list_usage_restriction_rule_ids_for_account(
    cls,
    session: Session,
    /,
    account_id: UUID,
    with_terminated: bool = False,
) -> list[UUID]:
    query = (
        cls.select(custom_autoload={})
        .filter(UsageRestrictionRule.account_id == account_id)
        .options(load_only(UsageRestrictionRule.id))
    )
    if not with_terminated:
        query = query.filter(UsageRestrictionRule.terminated_at.is_(None))
    usage_restriction_rules = session.execute(query).scalars().all()
    return [
        usage_restriction_rule.id
        for usage_restriction_rule in usage_restriction_rules
    ]

list_usage_restriction_rules_for_account classmethod 

list_usage_restriction_rules_for_account(
    session, /, account_id, with_terminated=False
)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
73
74
75
76
77
78
79
80
81
82
83
84
@classmethod
def list_usage_restriction_rules_for_account(
    cls,
    session: Session,
    /,
    account_id: UUID,
    with_terminated: bool = False,
) -> list[UsageRestrictionRule]:
    query = cls.select().filter(UsageRestrictionRule.account_id == account_id)
    if not with_terminated:
        query = query.filter(UsageRestrictionRule.terminated_at.is_(None))
    return list(session.execute(query).scalars().all())

model class-attribute instance-attribute 

model = UsageRestrictionRule

terminate_usage_restriction_rule classmethod 

terminate_usage_restriction_rule(session, /, id)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
129
130
131
132
133
134
135
136
137
138
139
@classmethod
def terminate_usage_restriction_rule(
    cls,
    session: Session,
    /,
    id: UUID,
) -> UsageRestrictionRule:
    usage_restriction_rule = cls.get_usage_restriction_rule(session, id)
    usage_restriction_rule.terminated_at = datetime.now()

    return usage_restriction_rule

update_usage_restriction_rule classmethod 

update_usage_restriction_rule(session, /, id, **data)
Source code in components/payment_gateway/subcomponents/rules/models/brokers/usage_restriction_rule.py 
116
117
118
119
120
121
122
123
124
125
126
127
@classmethod
def update_usage_restriction_rule(
    cls,
    session: Session,
    /,
    id: UUID,
    **data: Unpack[UsageRestrictionRuleUpdate],
) -> UsageRestrictionRule:
    usage_restriction_rule = cls.get_usage_restriction_rule(session, id)
    usage_restriction_rule.assign(data)

    return usage_restriction_rule

UsageRestrictionRuleUpdate

Bases: TypedDict

criteria instance-attribute 

criteria

end instance-attribute 

end

is_active instance-attribute 

is_active

start instance-attribute 

start