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=[] ) }