def __init__(self,
response=WithChallengeClientResponse,
children=None,
**kwargs):
super().__init__(
**kwargs,
description=('The result of a challenge-blocked method.'
' Contains information relevant to the open challenge'
' needed to complete the method execution.'),
response=response,
children=merge(
{
with_challenge_constants.CHALLENGE_COMPLETE:
Schema(
description=
'A flag indicating whether the challenge is complete',
types=types.BOOLEAN(),
),
with_challenge_constants.OPEN_CHALLENGE_ID:
Schema(
description='The ID of the open challenge',
types=types.UUID(),
),
},
children,
),
)
def __init__(self, field, **kwargs):
self.field = field
super().__init__(**kwargs,
client=Schema(response=PropertyResponse),
children={
set_constants.NULL: Schema(types=types.BOOLEAN()),
})
def __init__(self, Model):
self.model = Model
super().__init__(
origin=lock_constants.ORIGIN,
response=AccountSuperadminLockResponse,
children={
lock_constants.LOCK: Schema(types=types.BOOLEAN()),
lock_constants.ACCOUNT_ID: Schema(types=types.UUID()),
},
)
def __init__(self, Model, **kwargs):
self.model = Model
super().__init__(
**kwargs,
description=(
'The schema for the TransactionMatch get method.'
' Basic filters are available for the ID and'
' active status of the TransactionMatch.'
),
response=TransactionMatchGetResponse,
children={
get_constants.TRANSACTION_REPORT_ID: Schema(
description='Filter by the ID of the parent TransactionReport.',
types=types.UUID(),
),
get_constants.TRANSACTION_REPORT_TARGET_ADDRESS: Schema(
description='Filter by the target address of the parent TransactionReport.',
),
get_constants.TRANSACTION_REPORT_IS_ACTIVE: Schema(
description='Filter by the active status of the parent TransactionReport.',
types=types.BOOLEAN(),
),
get_constants.TRANSACTION_MATCH_ID: Schema(
description=(
'The ID of the TransactionMatch in question. This value'
' will override any filters applied.'
),
types=types.UUID(),
),
transaction_match_fields.IS_NEW: Schema(
description=(
'Filter by the new status of the TransactionMatch.'
),
types=types.BOOLEAN(),
),
transaction_match_fields.BLOCK_HASH: Schema(
description='Filter by the block hash of the TransactionMatch.',
),
},
)
def __init__(self, Model, mode=None, **kwargs):
self.model = Model
super().__init__(
**kwargs,
response=PrototypeResponse,
client=Schema(types=types.BOOLEAN()),
children={
schema_constants.ATTRIBUTES:
AttributesSchema(Model, mode=mode),
schema_constants.RELATIONSHIPS:
RelationshipsSchema(Model, mode=mode),
},
)
def passes_pre_response_checks(self, payload):
if self.active_response.active_type == types.BOOLEAN():
return True
values = payload.values()
if any(values) and not all(values):
self.active_response.add_error(model_schema_errors.UNIFORM_INCLUSIVE())
return False
if all(values):
self.active_response.is_inclusive = True
return super().passes_pre_response_checks(payload)
def __init__(self, Model):
self.model = Model
super().__init__(
description=(
'The schema for the TransactionReport create method.'),
response=TransactionReportCreateResponse,
origin=create_constants.ORIGIN,
children={
transaction_report_fields.IS_ACTIVE:
Schema(
description=(
'Whether or not the report should be initially active.'
),
types=types.BOOLEAN(),
),
transaction_report_fields.TARGET_ADDRESS:
Schema(
description=('The address to watch'),
types=types.STRING(),
),
transaction_report_fields.VALUE_EQUAL_TO:
Schema(
description=
('A match will be recorded if the integer Satoshi amount'
' of an output to the target address is equal to this value.'
' WARNING: cannot be used in conjunction with the value_less_than'
' or value_greater_than properties.'),
types=types.POSITIVE_INTEGER(),
),
transaction_report_fields.VALUE_LESS_THAN:
Schema(
description=
('A match will be recorded if the integer Satoshi amount'
' of an output to the target address is less than this value,'
' depending on the value of the value_greater_than property.'
' WARNING: cannot be used in conjunction with the value_equal_to'
' property.'),
types=types.POSITIVE_INTEGER(),
),
transaction_report_fields.VALUE_GREATER_THAN:
Schema(
description=
('A match will be recorded if the integer Satoshi amount'
' of an output to the target address is greater than this value,'
' depending on the value of the value_less_than property.'
' WARNING: cannot be used in conjunction with the value_equal_to'
' property.'),
types=types.POSITIVE_INTEGER(),
),
},
)
def __init__(self, Model, mode=None, **kwargs):
self.model = Model
self.mode = mode
super().__init__(
**kwargs,
response=AttributeResponse,
children={
attribute.name: Schema(
description='Attribute flag for {}'.format(attribute.name),
types=types.BOOLEAN(),
)
for attribute in Model.objects.attributes(mode=mode)
},
)
def __init__(self, Model, mode=None, **kwargs):
self.model = Model
self.mode = mode
super().__init__(
**kwargs,
response=RelationshipResponse,
children={
relationship.name: Schema(
description='',
types=types.BOOLEAN(),
)
for relationship in Model.objects.relationships(mode=mode)
},
)
class RelationshipSchema(StructureSchema):
default_types = force_array(StructureSchema.default_types) + [
types.BOOLEAN(),
]
def __init__(self, Model, mode=None, **kwargs):
self.model = Model
self.mode = mode
super().__init__(
**kwargs,
response=RelationshipResponse,
children={
relationship.name: Schema(
description='',
types=types.BOOLEAN(),
)
for relationship in Model.objects.relationships(mode=mode)
},
)
def get_available_errors(self):
return set.union(
super().get_available_errors(),
{
model_schema_errors.UNIFORM_INCLUSIVE(),
},
)
def passes_pre_response_checks(self, payload):
if self.active_response.active_type == types.BOOLEAN():
return True
values = payload.values()
if any(values) and not all(values):
self.active_response.add_error(
model_schema_errors.UNIFORM_INCLUSIVE())
return False
if all(values):
self.active_response.is_inclusive = True
return super().passes_pre_response_checks(payload)
def responds_to_valid_payload(self, payload, context):
if self.active_response.active_type == types.BOOLEAN():
self.active_response.should_include_attributes = payload
return
super().responds_to_valid_payload(payload, context)
def __init__(self,
response=WithPaymentClientResponse,
children=None,
**kwargs):
super().__init__(
**kwargs,
response=response,
children=merge(
{
with_payment_constants.PAYMENT_COMPLETE:
Schema(types=types.BOOLEAN()),
with_payment_constants.OPEN_PAYMENT_ID:
Schema(types=types.UUID()),
},
children,
),
)
def __init__(self, Model):
self.model = Model
super().__init__(
description=(
'Schema for the Account lock method.'
' Once lock is set to true, the account will be unusable'
' until lock is set to false by calling this method again.'),
response=AccountSubscribedLockResponse,
origin=lock_constants.ORIGIN,
children={
lock_constants.LOCK:
Schema(
description=(
'Value specifying the desired lock state of the account'
),
types=types.BOOLEAN(),
),
},
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=('The schema for the challenge result. Contains the'
' outcome of the evaluation.'),
children={
respond_constants.CHALLENGE_ID:
Schema(
description=
'The ID of the Challenge that is in the process of being verified',
types=types.UUID(),
),
respond_constants.IS_VERIFIED:
Schema(
description=
'A flag indicating whether the verification has been successful',
types=types.BOOLEAN(),
),
},
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=(
'The schema for the Payment get method.'
' It can be filtered by the open status of'
' the payment and the payment ID'
),
response=PaymentGetResponse,
children={
get_constants.PAYMENT_ID: Schema(
description='The payment ID',
types=types.UUID(),
),
payment_fields.IS_OPEN: Schema(
description='The payment open status',
types=types.BOOLEAN(),
),
},
)
def __init__(self, Model, **kwargs):
self.model = Model
super().__init__(
**kwargs,
description=('The schema for the FeeReport activate method.'),
response=FeeReportActivateResponse,
origin=activate_constants.ORIGIN,
children={
activate_constants.FEE_REPORT_ID:
Schema(
description='The ID of the FeeReport is question.',
types=types.UUID(),
),
fee_report_fields.IS_ACTIVE:
Schema(
description=('A boolean value that designates whether'
' the report should be active.'),
types=types.BOOLEAN(),
),
},
)
def __init__(self, Model, **kwargs):
self.model = Model
super().__init__(
**kwargs,
description=('The schema for the FeeReport get method.'
' Basic filters are available for the ID and'
' active status of the FeeReport.'),
response=FeeReportGetResponse,
children={
get_constants.FEE_REPORT_ID:
Schema(
description='The ID of the FeeReport in question.',
types=types.UUID(),
),
fee_report_fields.IS_ACTIVE:
Schema(
description='The active status of the FeeReport.',
types=types.BOOLEAN(),
),
},
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=('The schema for the Subscription get method.'
' Filters can be applied for the active status'
' and the ID of the subscription.'),
response=SubscriptionGetResponse,
children={
get_constants.SUBSCRIPTION_ID:
Schema(
description=('The subscription ID'),
types=types.UUID(),
),
subscription_fields.IS_ACTIVE:
Schema(
description=
('The subscription active status. If omitted, all subscriptions'
' are returned.'),
types=types.BOOLEAN(),
),
},
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=('The schema for the Challenge get method.'
' Returns instances of the Challenge class and'
' includes a simple filter for the open status'
' of each object.'),
response=ChallengeGetResponse,
children={
get_constants.CHALLENGE_ID:
Schema(
description=('The challenge ID'),
types=types.UUID(),
),
challenge_fields.IS_OPEN:
Schema(
description=('Filter the list of challenges'
' by their open states.'),
types=types.BOOLEAN(),
),
},
)
def __init__(self, Model, **kwargs):
self.model = Model
super().__init__(
**kwargs,
description=('The schema for the FeeReport create method.'),
response=FeeReportCreateResponse,
origin=create_constants.ORIGIN,
children={
fee_report_fields.BLOCKS_TO_INCLUDE:
Schema(
description=
('The number of blocks over which to calculate the average.'
' Defaults to 1 if omitted.'),
types=types.INTEGER(),
),
fee_report_fields.IS_ACTIVE:
Schema(
description=(
'Whether or not the report should be initially active.'
' Defaults to true if omitted.'),
types=types.BOOLEAN(),
),
},
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
template=TemplateSchema(types=types.BOOLEAN()),
)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
response=GetClientResponse,
template=TemplateSchema(types=types.BOOLEAN()),
)
def responds_to_valid_payload(self, payload, context):
if self.active_response.active_type == types.BOOLEAN():
self.active_response.should_include_attributes = payload
return
super().responds_to_valid_payload(payload, context)