class RefConsumersSegmentFilterStats(Resource):
condition = {
'tag_name': fields.Str(validate=validate_tag_name),
'tag_values': fields.DelimitedList(fields.Str())
}
tag_filter_schema = {
'conditions': fields.DelimitedList(fields.Nested(condition))
}
input_args = {
'business_account_id': fields.Int(required=False),
'store_ids': fields.DelimitedList(fields.Int(required=False)),
'date_param_cd': fields.Str(validate=validate_date_param),
'tag_filter': fields.Nested(tag_filter_schema)
}
@use_args(input_args)
def get(self, args):
return {"message": "Try with POST calls. You may feel lucky!"}, 303
@use_args(input_args)
def post(self, args):
##LOGIC FOR CAMPAIGN STATS - Need to connect with Anupam
return {
"total_count": 1245,
"filtered_count": 123,
"overlapping_count": 500,
"active_campaigns": [123, 345]
}
class PutLockPasswordArgs(object):
resource_fields = {
"password": fields.Str(
description='The six digit password',
required=False,
validate=lambda p: len(p) == 6 and p.isdigit(),
),
"expiration": fields.Int(
description='The ms since unix epoch to expire the password',
required=False,
),
"activeDays": fields.DelimitedList(
EnumField(PasswordDays),
description='A list of the days that the password is available',
required=False,
),
"activeTimes": fields.DelimitedList(
fields.Str(
description='A time formatted as HH:MM',
validate=lambda s: re.fullmatch(
s, '([0-1]?[0-9]|2[0-3]):[0-5][0-9]')
),
description=(
'A length 2 list of start and end times (local to the lock)'
'in HH:MM format for when the password is active.'
'Example: [08:00, 12:00]. An empty list can be passed to'
'have the lock always enabled'),
validate=lambda l: len(l) == 2 or len(l) == 0,
required=False,
),
}
def parse_global_params(self, query, params, database):
webargs_schema = {
"select": fields.DelimitedList(fields.Str()),
"limit": fields.Int(missing=self.config["LIMIT_DEFAULT"]),
"orderby": fields.DelimitedList(fields.Str()),
"desc": fields.Bool(),
}
global_params = parser.parse(webargs_schema, request)
# global_params = {
# "select": request.args.get("select"),
# "limit": int(request.args.get("limit", 100)),
# "orderby": request.args.get("orderby"),
# "desc": request.args.get("desc"),
# }
# Remove trailing semicolon
if query[-1] == ";":
query = query[:-1]
# Make room for appension
query += " "
params = params.copy()
if global_params.get("orderby") is not None:
columns = global_params["orderby"]
if self.is_valid_columns(database, query, params, columns):
columns = ",".join(f"`{col}`" for col in columns)
query += f"ORDER BY {columns} "
else:
abort(404)
if global_params.get("desc") is not None:
if global_params["desc"]:
query += "DESC "
if global_params.get("limit") > 0:
query += f"LIMIT {self.placeholder} "
params.append(global_params["limit"])
if global_params.get("select") is not None:
columns = global_params["select"]
if self.is_valid_columns(database, query, params, columns):
columns = ",".join(f"`{col}`" for col in columns)
query = query.replace("SELECT *", f"SELECT {columns}")
else:
abort(404)
# Trailing space cleanup with semicolon
if query[-1] == " ":
query = query[:-1] + ";"
return query, params
def _api_v1_versions_patch(
self, version_uid: str, protected: fields.Bool(missing=None),
labels: fields.DelimitedList(fields.Str(), missing=None)
) -> StringIO:
version_uid_obj = VersionUid(version_uid)
if labels is not None:
label_add, label_remove = InputValidation.parse_and_validate_labels(
labels)
else:
label_add, label_remove = [], []
result = StringIO()
with Benji(self._config) as benji_obj:
try:
if protected is not None:
benji_obj.protect(version_uid_obj, protected=protected)
for name, value in label_add:
benji_obj.add_label(version_uid_obj, name, value)
for name in label_remove:
benji_obj.rm_label(version_uid_obj, name)
benji_obj.export_any(
{
'versions': [
benji_obj.get_version_by_uid(
version_uid=version_uid_obj)
]
},
result,
ignore_relationships=[((Version, ), ('blocks', ))])
except KeyError:
response.status = f'410 Version {version_uid} not found.'
return result
def test_delimited_list_custom_delimiter(web_request, parser):
web_request.json = {"ids": "1|2|3"}
schema_cls = dict2schema({"ids": fields.DelimitedList(fields.Int(), delimiter="|")})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed["ids"] == [1, 2, 3]
class FiatExchangeRatesSchema(BaseSchema):
currencies = webargs_fields.DelimitedList(FiatAssetField(), missing=None)
class Meta:
strict = True
# decoding to a dict is required by the @use_kwargs decorator from webargs
decoding_class = dict
def switch(case):
return {
int: wf.Int(missing=None),
float: wf.Float(missing=None),
bool: wf.Bool(missing=None),
list: wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
}.get(case)
def __init__(self):
args = {
'keyword': fields.Str(),
'page': fields.Int(missing=1, validate=validate.Range(min=1)),
'per_page': fields.Int(missing=10, validate=validate.Range(min=1)),
'plan_trigger_time': fields.DelimitedList(fields.DateTime()),
'status': fields.Int(),
'task_ids': fields.DelimitedList(fields.Int()),
}
parsed_args = parser.parse(args, request, location='querystring')
self.count = parsed_args['per_page']
self.keyword = parsed_args.get('keyword')
self.plan_trigger_time = parsed_args.get('plan_trigger_time')
self.start = (parsed_args['page'] - 1) * parsed_args['per_page']
self.status = parsed_args.get('status')
self.task_ids = parsed_args.get('task_ids')
def test_delimited_list_load_list(web_request, parser):
web_request.json = {"ids": [1, 2, 3]}
schema_cls = dict2schema({"ids": fields.DelimitedList(fields.Int())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed["ids"] == [1, 2, 3]
def test_delimited_list_load_list(web_request, parser):
web_request.json = {'ids': [1, 2, 3]}
schema_cls = argmap2schema({'ids': fields.DelimitedList(fields.Int())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed['ids'] == [1, 2, 3]
def filter_value_type_to_request_arg_type(name,
value_type,
allow_multiple,
load_from=None):
if value_type == str:
arg_type = fields.Str(load_from=load_from or name,
location='query')
elif value_type == float:
arg_type = fields.Float(load_from=load_from or name,
location='query')
elif value_type == int:
arg_type = fields.Int(load_from=load_from or name,
location='query')
elif value_type == datetime:
arg_type = fields.DateTime(load_from=load_from or name,
location='query')
else:
raise Exception(
"Unsupported value type '{}' for a request argument".format(
value_type))
if allow_multiple:
arg_type = fields.DelimitedList(arg_type,
load_from=load_from or name,
location='query')
return arg_type
class ItemFactory:
query_args = {
"fields": fields.DelimitedList(fields.Str()),
"filter": fields.Str(validate=validate.Length(min=2), missing="id")
}
def __init__(self, controller, model):
self.controller = controller
self.model = model
def get(self, identifier, **kwargs):
mask = "*" if not kwargs.get("fields") else ",".join(
kwargs.get("fields"))
filter_by = kwargs.get("filter")
return marshal(
[dict(i) for i in self.controller().get({filter_by: identifier})],
self.model,
mask=mask), 200
def patch(self, identifier, **kwargs):
return marshal(dict(self.controller().update(int(identifier), kwargs)),
self.model), 200
def delete(self, identifier):
operation = self.controller().delete(int(identifier))
return make_response("", 200) if operation else make_response("", 404)
def _protect(
self, version_uid: str, protected: fields.Bool(missing=None),
labels: fields.DelimitedList(fields.Str(), missing=None)
) -> StringIO:
version_uid_obj = VersionUid(version_uid)
if labels is not None:
label_add, label_remove = InputValidation.parse_and_validate_labels(
labels)
else:
label_add, label_remove = [], []
benji_obj = None
try:
benji_obj = Benji(self._config)
if protected is True:
benji_obj.protect(version_uid_obj)
elif protected is False:
benji_obj.unprotect(version_uid_obj)
for name, value in label_add:
benji_obj.add_label(version_uid_obj, name, value)
for name in label_remove:
benji_obj.rm_label(version_uid_obj, name)
result = StringIO()
benji_obj.export_any(
{'versions': [benji_obj.ls(version_uid=version_uid_obj)]},
result,
ignore_relationships=[((Version, ), ('blocks', ))])
return result
finally:
if benji_obj:
benji_obj.close()
def test_delimited_list_custom_delimiter(web_request, parser):
web_request.json = {'ids': '1|2|3'}
schema_cls = argmap2schema({'ids': fields.DelimitedList(fields.Int(), delimiter='|')})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed['ids'] == [1, 2, 3]
def user_merge():
args = parser.parse({
'user_key':
wf.Str(missing=None),
'user_keys':
wf.DelimitedList(wf.Str(), delimiter=',', required=True),
})
user_db_keys = [ndb.Key(urlsafe=k) for k in args['user_keys']]
user_dbs = ndb.get_multi(user_db_keys)
if len(user_dbs) < 2:
flask.abort(400)
user_dbs.sort(key=lambda user_db: user_db.created)
merged_user_db = user_dbs[0]
auth_ids = []
permissions = []
is_admin = False
is_active = False
for user_db in user_dbs:
auth_ids.extend(user_db.auth_ids)
permissions.extend(user_db.permissions)
is_admin = is_admin or user_db.admin
is_active = is_active or user_db.active
if user_db.key.urlsafe() == args['user_key']:
merged_user_db = user_db
auth_ids = sorted(list(set(auth_ids)))
permissions = sorted(list(set(permissions)))
merged_user_db.permissions = permissions
merged_user_db.admin = is_admin
merged_user_db.active = is_active
merged_user_db.verified = False
form_obj = copy.deepcopy(merged_user_db)
form_obj.user_key = merged_user_db.key.urlsafe()
form_obj.user_keys = ','.join(args['user_keys'])
form = UserMergeForm(obj=form_obj)
if form.validate_on_submit():
form.populate_obj(merged_user_db)
merged_user_db.auth_ids = auth_ids
merged_user_db.put()
deprecated_keys = [k for k in user_db_keys if k != merged_user_db.key]
merge_user_dbs(merged_user_db, deprecated_keys)
return flask.redirect(
flask.url_for('user_update', user_id=merged_user_db.key.id()), )
return flask.render_template(
'user/user_merge.html',
title='Merge Users',
html_class='user-merge',
user_dbs=user_dbs,
merged_user_db=merged_user_db,
form=form,
auth_ids=auth_ids,
api_url=flask.url_for('api.admin.user.list'),
)
class PostUserLockArgs(object):
resource_fields = {
"ownedLockIds": fields.DelimitedList(
fields.Str(),
description="A list of lock ids to add to the user",
required=True
),
}
def test_delimited_list_passed_invalid_type(web_request, parser):
web_request.json = {"ids": 1}
schema_cls = dict2schema({"ids": fields.DelimitedList(fields.Int())})
schema = schema_cls()
with pytest.raises(ValidationError) as excinfo:
parser.parse(schema, web_request)
assert excinfo.value.messages == {"ids": ["Not a valid list."]}
class GrampsObjectsResource(GrampsObjectResourceHelper, Resource):
"""Resource for multiple objects."""
@use_args(
{
"gramps_id": fields.Str(validate=validate.Length(min=1)),
"strip": fields.Str(validate=validate.Length(equal=0)),
"keys": fields.DelimitedList(fields.Str(), missing=[]),
"skipkeys": fields.DelimitedList(fields.Str(), missing=[]),
"profile": fields.Str(validate=validate.Length(equal=0)),
"extend": fields.DelimitedList(fields.Str(validate=validate.Length(min=1))),
"filter": fields.Str(validate=validate.Length(min=1)),
"rules": fields.Str(validate=validate.Length(min=1)),
},
location="query",
)
def get(self, args: Dict) -> Response:
"""Get all objects."""
if "gramps_id" in args:
obj = self.get_object_from_gramps_id(args["gramps_id"])
if obj is None:
abort(404)
return self.response(200, [self.object_extend(obj, args)], args)
query_method = self.db_handle.method(
"get_%s_from_handle", self.gramps_class_name
)
if "filter" in args or "rules" in args:
handle_list = apply_filter(self.db_handle, args, self.gramps_class_name)
return self.response(
200,
[
self.object_extend(query_method(handle), args)
for handle in handle_list
],
args,
)
iter_method = self.db_handle.method("iter_%s_handles", self.gramps_class_name)
return self.response(
200,
[
self.object_extend(query_method(handle), args)
for handle in iter_method()
],
args,
)
def _api_v1_versions_metadata_restore_create(
self, version_uids: fields.DelimitedList(fields.Str, required=True),
storage_name: fields.Str(missing=None)
) -> None:
version_uid_objs = [
VersionUid(version_uid) for version_uid in version_uids
]
with Benji(self._config) as benji_obj:
benji_obj.metadata_restore(version_uid_objs, storage_name)
class ComparisonGetParams(Schema):
contributions = fields.DelimitedList(fields.String(),
required=True,
validate=validate.Length(min=2))
response_hash = fields.String()
save_response = fields.Boolean()
type = fields.String()
def test_delimited_list_empty_string(web_request, parser):
web_request.json = {"dates": ""}
schema_cls = Schema.from_dict({"dates": fields.DelimitedList(fields.Str())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed["dates"] == []
data = schema.dump(parsed)
assert data["dates"] == ""
def test_delimited_list_default_delimiter(web_request, parser):
web_request.json = {"ids": "1,2,3"}
schema_cls = Schema.from_dict({"ids": fields.DelimitedList(fields.Int())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed["ids"] == [1, 2, 3]
data = schema.dump(parsed)
assert data["ids"] == "1,2,3"
def test_delimited_list_as_string(web_request, parser):
web_request.json = {'ids': '1,2,3'}
schema_cls = argmap2schema({'ids': fields.DelimitedList(fields.Int(), as_string=True)})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed['ids'] == [1, 2, 3]
dumped = schema.dump(parsed).data
assert dumped['ids'] == '1,2,3'
class GrampsObjectResource(GrampsObjectResourceHelper, Resource):
"""Resource for a single object."""
@use_args(
{
"strip": fields.Str(validate=validate.Length(equal=0)),
"keys": fields.DelimitedList(fields.Str(), missing=[]),
"skipkeys": fields.DelimitedList(fields.Str(), missing=[]),
"profile": fields.Str(validate=validate.Length(equal=0)),
"extend": fields.DelimitedList(fields.Str(validate=validate.Length(min=1))),
},
location="query",
)
def get(self, args: Dict, handle: str) -> Response:
"""Get the object."""
try:
obj = self.get_object_from_handle(handle)
except HandleError:
abort(404)
return self.response(200, self.object_extend(obj, args), args)
def test_delimited_list_default_delimiter(web_request, parser):
web_request.json = {"ids": "1,2,3"}
schema_cls = dict2schema({"ids": fields.DelimitedList(fields.Int())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed["ids"] == [1, 2, 3]
dumped = schema.dump(parsed)
data = dumped.data if MARSHMALLOW_VERSION_INFO[0] < 3 else dumped
assert data["ids"] == [1, 2, 3]
def test_delimited_list_load_list_errors(web_request, parser):
web_request.json = {"ids": [1, 2, 3]}
schema_cls = dict2schema({"ids": fields.DelimitedList(fields.Int())})
schema = schema_cls()
with pytest.raises(ValidationError) as excinfo:
parser.parse(schema, web_request)
exc = excinfo.value
assert isinstance(exc, ValidationError)
errors = exc.args[0]
assert errors["ids"] == ["Not a valid delimited list."]
def test_delimited_list_default_delimiter(web_request, parser):
web_request.json = {'ids': '1,2,3'}
schema_cls = argmap2schema({'ids': fields.DelimitedList(fields.Int())})
schema = schema_cls()
parsed = parser.parse(schema, web_request)
assert parsed['ids'] == [1, 2, 3]
dumped = schema.dump(parsed)
data = dumped.data if MARSHMALLOW_VERSION_INFO[0] < 3 else dumped
assert data['ids'] == [1, 2, 3]
class TranslationsResource(ProtectedResource, GrampsJSONEncoder):
"""Translations resource."""
@use_args(
{
"locale":
fields.Str(missing=None, validate=validate.Length(min=1, max=5)),
"sort":
fields.DelimitedList(fields.Str(validate=validate.Length(min=1))),
},
location="query",
)
def get(self, args: Union[Dict, None] = None) -> Response:
"""Get available translations."""
default_locale = GrampsLocale(lang="en")
current_locale = get_locale_for_language(args["locale"], default=True)
catalog = default_locale.get_language_dict()
translations = []
for entry in catalog:
native_locale = GrampsLocale(lang=catalog[entry])
translations.append({
"default":
entry,
"current":
current_locale.translation.sgettext(entry),
"language":
catalog[entry],
"native":
native_locale.translation.sgettext(entry),
})
sort = Sort(default_locale=default_locale,
current_locale=current_locale)
lookup = {
"current": sort.get_current_key,
"default": sort.get_default_key,
"language": sort.get_language_key,
"native": sort.get_native_key,
}
if "sort" not in args:
args["sort"] = ["language"]
for sort_key in args["sort"]:
sort_key = sort_key.strip()
reverse = False
if sort_key[:1] == "-":
reverse = True
sort_key = sort_key[1:]
if sort_key not in lookup:
abort(422)
translations.sort(key=lambda x: lookup[sort_key](x),
reverse=reverse)
return self.response(200, translations)
def __init__(self):
args = {
'ids': fields.DelimitedList(fields.Int, allow_none=True),
'name': fields.Str(allow_none=True),
'page': fields.Int(missing=1, validate=validate.Range(min=1)),
'per_page': fields.Int(missing=10, validate=validate.Range(min=1)),
}
parsed_args = parser.parse(args, request, location='querystring')
self.ids = parsed_args.get('ids')
self.name = parsed_args.get('name')
self.page = parsed_args['page']
self.per_page = parsed_args['per_page']
class DeleteHardwarePasswordsArgs(object):
resource_fields = {
"passwordIds": fields.DelimitedList(
fields.Str(
description="A valid password id",
required=True
),
description="A list of valid password ids",
required=True,
missing=[]
)
}
