def respond(self,
payload={},
context=None,
payment_id=None,
check_payment=False,
**kwargs):
if not check_payment:
return super().respond(payload=payload, context=context, **kwargs)
payload = merge(
payload,
{
with_payment_constants.PAYMENT_COMPLETE: payment_id is None,
},
)
if payment_id is not None:
payload = merge(
payload,
{
with_payment_constants.OPEN_PAYMENT_ID: payment_id,
},
)
return super().respond(payload=payload, context=context, **kwargs)
def respond(self,
payload=None,
context=None,
challenge_id=None,
check_challenge=False,
**kwargs):
if not check_challenge:
return super().respond(payload=payload, context=context, **kwargs)
payload = merge(
payload,
{
with_challenge_constants.CHALLENGE_COMPLETE:
challenge_id is None,
},
)
if challenge_id is not None:
payload = merge(
payload,
{
with_challenge_constants.OPEN_CHALLENGE_ID: challenge_id,
},
)
return super().respond(payload=payload, context=context, **kwargs)
def test_merge(self):
d = {1: 2}
merge_values(d, 3, 4); assert d == {1: 2, 3: 4}
d = {1: 2}
merge_values(d, 1, 3); assert d == {1: 3}
d, d2 = {1: {2: 3}}, {1: {2: 4}}
res = merge(d, d2)
assert res == {1: {2: 4}}, repr(res)
d, d2 = {1: {2: 3}}, [(1, {2: 4})]
res = merge(d, d2)
assert res == {1: {2: 4}}, repr(res)
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=(
'Welcome to the Transactino interface'
' Please refer to the README and the glossary'
' for more information.'
),
children={
api_constants.SCHEMA: StructureSchema(
description='The schema accepts data in plaintext JSON and interacts with the API',
children=merge(
CommonSchema(mode=mode_constants.ANONYMOUS).children,
{
api_constants.MODELS: StructureSchema(
description='Models available to the user',
children={
Model.__name__: Model.objects.schema(mode=mode_constants.ANONYMOUS)
for Model
in [
Account,
System,
]
},
),
},
),
),
},
)
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, **kwargs):
super().__init__(
**kwargs,
children=merge(
{
api_constants.SCHEMA:
StructureSchema(children={
api_constants.MODELS:
ModelsSchemaWithExternal(children={
Model.__name__: Model.objects.schema(
mode=mode_constants.SUPERADMIN)
for Model in [
Account,
Address,
Challenge,
Discount,
IP,
Payment,
Subscription,
FeeReport,
]
}, ),
}, ),
}, ),
)
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, context=None, **kwargs):
models = [
Account,
Address,
Announcement,
Challenge,
System,
]
account = context.get_account()
if account.is_verified:
models.extend([
Subscription,
Payment,
])
super().__init__(
**kwargs,
description=('The account does not have an active subscription.'
' Refer to the Subscription model to create one.'),
children={
api_constants.SCHEMA:
TransactinoControlSchema(
description=
'The schema accepts data in plaintext JSON and interacts with the API',
children=merge(
CommonSchema().children,
{
api_constants.MODELS:
ModelsSchemaWithExternal(
description='Models available to the user',
children={
Model.__name__: Model.objects.schema(
mode=mode_constants.UNSUBSCRIBED)
for Model in models
},
),
},
),
),
},
)
def has_matching_rammetid(self, umbrella_org_id, start_date, end_date, week_day, start_time, end_time):
times = []
query = current_app.db_session.query(RammetidSlot)
slots = query.filter(
RammetidSlot.start_date <= cast(start_date, Date),
RammetidSlot.end_date >= cast(end_date, Date),
week_day == RammetidSlot.week_day,
umbrella_org_id == Rammetid.umbrella_organisation_id,
).order_by(RammetidSlot.start_time, RammetidSlot.end_time).all()
# create list of time-periods for all slots
for slot in slots:
times.append((slot.start_time, slot.end_time))
# return if any merged slot covers whole time-period
if any(i[0] <= start_time and i[1] >= end_time for i in merge(times)):
return True
return False
def __init__(self, **kwargs):
super().__init__(
**kwargs,
description=(
'This account has an active subscription.'
' Please refer to the README and review the available models.'
),
children={
api_constants.SCHEMA:
TransactinoControlSchema(
description=
'The schema accepts data in plaintext JSON and interacts with the API',
children=merge(
CommonSchema().children,
{
api_constants.MODELS:
ModelsSchemaWithExternal(
description='Models available to the user',
children={
Model.__name__: Model.objects.schema(
mode=mode_constants.SUBSCRIBED)
for Model in [
Account,
Address,
Announcement,
System,
Challenge,
IP,
Payment,
Subscription,
FeeReport,
TransactionReport,
TransactionMatch,
]
},
),
},
),
),
},
)
def set_active(skin, variant = None, update_gui = False, callback = None):
'Changes the active skin.'
log.info('set_active(%r, %r)', skin, variant)
app = GetApp()
global activeTree
# Search all resource_paths for skin
skinname = skin
for rp in resource_paths:
skin = path(rp) / 'skins' / skinname
skinpath = skin / SKIN_FILENAME
if skinpath.isfile():
break
import hooks
hooks.notify('skin.set.pre', skin, variant)
# Find the variant file, if specified.
if variant is not None:
variant = skin / VARIANT_DIR / variant + '.yaml'
default_path = resource_paths[0] / 'skins' / 'default' / SKIN_FILENAME
paths = [default_path]
insert_position = 1
if os.path.basename(skin) == 'native':
paths.append(resource_paths[0] / path('skins') / 'silverblue' / SKIN_FILENAME)
if not skinpath.isfile():
log.critical('cannot find %r (%r.isfile() == False, defaulting to silverblue', skin, skinpath)
skin = resource_paths[0] / path('skins') / 'silverblue'
skinpath = skin / SKIN_FILENAME
variant = None
if default_path.abspath() != skinpath.abspath():
paths.append(skinpath)
if variant is not None:
if variant.isfile():
paths.append(variant)
else:
log.warning('cannot find variant %r for skin %r', variant, skin)
if not update_gui and hasattr(app, 'skin') and \
app.skin.paths == paths:
log.info('skin did not change, returning')
with traceguard:
load_skinfonts(paths)
# load YAML from disk
log.info('loading YAML from %d path(s):\n %r', len(paths), '\n '.join(paths))
trees = get_skintrees(skin, paths, insert_position)
# Ignore AppDefaults in all skins except default
for tree in trees[1:]:
tree.pop('appdefaults', None)
# copy the default tree in case there is an exception later
default_tree = deepcopy(trees[0])
# merge keys from different trees into one (case insensitive)
combined_tree = merge(*trees, **dict(keytransform = lambda k: getattr(k, 'lower', lambda k: k)()))
# create a skin storage object (transformation below depends on this being
# in the app)
if not hasattr(app, 'skin'):
app.skin = S()
app.skin.update(path = skinpath.parent, paths = get_image_load_paths(paths))
for pretransform in pretransforms:
pretransform(combined_tree)
# do skin transformation, creating images, brushes, etc.
try:
finaltree = transform(combined_tree)
except Exception, e:
MessageBox('There was an error processing skin "%s":\n\n%s' % (skin, str(e)),
'Skin Error')
# on an exception try loading the default tree
print_exc()
finaltree = transform(default_tree)
