def _enforce_retention_policy(
self, rules_spec: fields.Str(required=True),
filter_expression: fields.Str(missing=None),
dry_run: fields.Bool(missing=False),
keep_metadata_backup: fields.Bool(missing=False),
group_label: fields.Str(missing=None)
) -> None:
benji_obj = None
try:
benji_obj = Benji(self._config)
dismissed_versions = benji_obj.enforce_retention_policy(
filter_expression=filter_expression,
rules_spec=rules_spec,
dry_run=dry_run,
keep_metadata_backup=keep_metadata_backup,
group_label=group_label)
result = StringIO()
benji_obj.export_any(
{'versions': dismissed_versions},
result,
ignore_relationships=[((Version, ), ('blocks', ))],
)
return result
finally:
if benji_obj:
benji_obj.close()
class SettingsSchema(mm.Schema):
admin_principals = PrincipalList(allow_groups=True)
authorized_principals = PrincipalList(allow_groups=True)
tileserver_url = fields.String(validate=[
validate.URL(schemes={'http', 'https'}),
lambda value: all(x in value for x in ('{x}', '{y}', '{z}'))
],
allow_none=True)
booking_limit = fields.Int(validate=[validate.Range(min=1)])
notifications_enabled = fields.Bool()
notification_before_days = fields.Int(
validate=[validate.Range(min=1, max=30)])
notification_before_days_weekly = fields.Int(
validate=[validate.Range(min=1, max=30)])
notification_before_days_monthly = fields.Int(
validate=[validate.Range(min=1, max=30)])
end_notifications_enabled = fields.Bool()
end_notification_daily = fields.Int(
validate=[validate.Range(min=1, max=30)])
end_notification_weekly = fields.Int(
validate=[validate.Range(min=1, max=30)])
end_notification_monthly = fields.Int(
validate=[validate.Range(min=1, max=30)])
excluded_categories = ModelList(Category)
grace_period = fields.Int(validate=[validate.Range(min=0, max=24)],
allow_none=True)
def make_sort_args(default=None,
multiple=True,
validator=None,
default_hide_null=False,
default_nulls_large=True):
description = 'Provide a field to sort by. Use - for descending order.'
if multiple:
sort_field = fields.List(
fields.Str(validate=validator),
missing=default,
description=description,
)
else:
sort_field = fields.Str(
missing=default,
validate=validator,
description=description,
)
return {
'sort':
sort_field,
'sort_hide_null':
fields.Bool(missing=default_hide_null,
description='Hide null values on sorted column(s).'),
'sort_nulls_large':
fields.Bool(
missing=default_nulls_large,
description='Treat null values as large on sorted column(s)',
)
}
class ContributionResource(Resource):
"""
Endpoint for contributions in the spreadsheet.
"""
query_parameters = {
"category": fields.Str(),
"status": fields.Str(),
"author": fields.Str(),
"moderator": fields.Str(),
"staff_picked": fields.Bool(),
"review_status": fields.Str(),
"url": fields.Str(),
"voted_on": fields.Bool(),
"repository": fields.Str(),
}
@use_args(query_parameters)
def get(self, query_parameters):
"""
Uses the given query parameters to search for contributions in the
database.
"""
contributions = [
json.loads(json_util.dumps(without_score(c)))
for c in DB.contributions.find(query_parameters)
]
return jsonify(contributions)
def _rm(
self, version_uid: str, force: fields.Bool(missing=False),
keep_metadata_backup: fields.Bool(missing=False),
override_lock: fields.Bool(missing=False)
) -> None:
version_uid_obj = VersionUid(version_uid)
disallow_rm_when_younger_than_days = self._config.get(
'disallowRemoveWhenYounger', types=int)
benji_obj = None
try:
benji_obj = Benji(self._config)
result = StringIO()
# Do this before deleting the version
benji_obj.export_any({'versions': [version_uid_obj]},
result,
ignore_relationships=[((Version, ),
('blocks', ))])
benji_obj.rm(version_uid_obj,
force=force,
disallow_rm_when_younger_than_days=
disallow_rm_when_younger_than_days,
keep_metadata_backup=keep_metadata_backup,
override_lock=override_lock)
return result
finally:
if benji_obj:
benji_obj.close()
class RHUpdateRoom(RHRoomAdminBase):
@use_args({
'verbose_name': fields.Str(allow_none=True),
'site': fields.Str(allow_none=True),
'building': fields.String(validate=lambda x: x is not None),
'floor': fields.String(validate=lambda x: x is not None),
'number': fields.String(validate=lambda x: x is not None),
'longitude': fields.Float(allow_none=True),
'latitude': fields.Float(allow_none=True),
'is_reservable': fields.Bool(allow_none=True),
'reservations_need_confirmation': fields.Bool(allow_none=True),
'notification_emails': fields.List(fields.Email()),
'notification_before_days': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'notification_before_days_weekly': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'notification_before_days_monthly': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'notifications_enabled': fields.Bool(),
'end_notification_daily': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'end_notification_weekly': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'end_notification_monthly': fields.Int(validate=lambda x: 1 <= x <= 30, allow_none=True),
'end_notifications_enabled': fields.Bool(),
'booking_limit_days': fields.Int(validate=lambda x: x >= 1, allow_none=True),
'owner': Principal(validate=lambda x: x is not None, allow_none=True),
'key_location': fields.Str(),
'telephone': fields.Str(),
'capacity': fields.Int(validate=lambda x: x >= 1),
'division': fields.Str(allow_none=True),
'surface_area': fields.Int(validate=lambda x: x >= 0, allow_none=True),
'max_advance_days': fields.Int(validate=lambda x: x >= 1, allow_none=True),
'comments': fields.Str(),
})
def _process(self, args):
update_room(self.room, args)
RHRoomsPermissions._jsonify_user_permissions.clear_cached(session.user)
return jsonify(room_update_schema.dump(self.room, many=False))
def add_user_routes(app, system_email, bcrypt):
""" Create routes related to user management
Args:
app - Flask app to add routes to
system_email - Sender address to use for emails
bcrypt - Password hashing Bcrypt associated with app
"""
@app.route("/v1/list_user_emails/", methods=["GET"])
@requires_login
def list_user_emails_route():
""" list all users """
return list_user_emails()
@app.route("/v1/list_submission_users/", methods=["GET"])
@requires_login
@use_kwargs({'is_fabs': webargs_fields.Bool(missing=False)})
def list_submission_users_route(is_fabs):
""" List all users with submissions that the requesting user has permissions for """
return list_submission_users(is_fabs)
@app.route("/v1/active_user/", methods=["GET"])
@requires_login
def active_user():
""" gets the current user information """
return JsonResponse.create(StatusCode.OK,
json_for_user(g.user, session['sid']))
@app.route("/v1/set_skip_guide/", methods=["POST"])
@requires_login
@use_kwargs({'skip_guide': webargs_fields.Bool(required=True)})
def set_skip_guide(skip_guide):
""" Sets skip_guide param for current user """
account_manager = AccountHandler(request, bcrypt=bcrypt)
return account_manager.set_skip_guide(skip_guide)
def _api_v1_versions_delete(
self, version_uid: str, force: fields.Bool(missing=False),
keep_metadata_backup: fields.Bool(missing=False),
override_lock: fields.Bool(missing=False)
) -> StringIO:
version_uid_obj = VersionUid(version_uid)
result = StringIO()
with Benji(self._config) as benji_obj:
try:
# Do this before deleting the version
benji_obj.export_any(
{
'versions': [
benji_obj.get_version_by_uid(
version_uid=version_uid_obj)
]
},
result,
ignore_relationships=[((Version, ), ('blocks', ))])
benji_obj.rm(version_uid_obj,
force=force,
keep_metadata_backup=keep_metadata_backup,
override_lock=override_lock)
except KeyError:
response.status = f'410 Version {version_uid} not found.'
return result
def make_sort_args(default=None, validator=None, default_hide_null=False,
default_nulls_only=False, default_sort_nulls_last=False, show_nulls_last_arg=True,
additional_description=''):
args = {
'sort': fields.Str(
missing=default,
validate=validator,
description='Provide a field to sort by. Use `-` for descending order.\n{}'.format(
additional_description
),
),
'sort_hide_null': fields.Bool(
missing=default_hide_null,
description='Hide null values on sorted column(s).'
),
'sort_null_only': fields.Bool(
missing=default_nulls_only,
description='Toggle that filters out all rows having sort column that is non-null'
),
}
if show_nulls_last_arg:
args['sort_nulls_last'] = fields.Bool(
missing=default_sort_nulls_last,
description='Toggle that sorts null values last'
)
return args
class RHSearchRooms(RHRoomBookingBase):
@use_args(dict(search_room_args, **{
'unavailable': fields.Bool(missing=False),
'admin_override_enabled': fields.Bool(missing=False)
}))
def _process(self, args):
filter_availability = all(x in args for x in ('start_dt', 'end_dt', 'repeat_frequency', 'repeat_interval'))
only_unavailable = args.pop('unavailable')
admin_override_enabled = args.pop('admin_override_enabled')
if not filter_availability:
availability = None
if only_unavailable:
raise UnprocessableEntity('Required data to filter by availability is not present')
else:
availability = not only_unavailable
search_query = search_for_rooms(args, allow_admin=admin_override_enabled, availability=availability)
rooms = [(id_, room_name) for id_, room_name, in search_query.with_entities(Room.id, Room.full_name)]
# We can't filter by blocking's acl in the search_query, so we need to adjust the results
rooms = self._adjust_blockings(rooms, args, availability)
room_ids = [room[0] for room in rooms]
if filter_availability:
room_ids_without_availability_filter = [
id_ for id_, in search_for_rooms(args, allow_admin=admin_override_enabled).with_entities(Room.id)
]
else:
room_ids_without_availability_filter = room_ids
return jsonify(rooms=room_ids, rooms_without_availability_filter=room_ids_without_availability_filter,
total=len(room_ids_without_availability_filter), availability_days=self._get_date_range(args))
def _get_date_range(self, filters):
try:
start_dt, end_dt = filters['start_dt'], filters['end_dt']
repetition = filters['repeat_frequency'], filters['repeat_interval']
except KeyError:
return None
return [dt.date().isoformat() for dt in ReservationOccurrence.iter_start_time(start_dt, end_dt, repetition)]
def _adjust_blockings(self, rooms, filters, availability):
if availability is None:
return rooms
blocked_rooms = get_blockings_with_rooms(filters['start_dt'], filters['end_dt'])
nonoverridable_blocked_rooms = filter_blocked_rooms(blocked_rooms, nonoverridable_only=True)
if availability:
# Remove nonoverridable blockings from available rooms
nonoverridable_blocked_rooms_ids = [room.room_id for room in nonoverridable_blocked_rooms]
rooms = [room for room in rooms if room[0] not in nonoverridable_blocked_rooms_ids]
else:
# Add nonoverridable blockings to unavailable rooms and re-sort results
rooms_ids = [room[0] for room in rooms]
missing_rooms = [(room.room_id, room.room.full_name) for room in nonoverridable_blocked_rooms
if room.room_id not in rooms_ids]
if filters.get('favorite'):
favorites = {r.id for r in session.user.favorite_rooms if not r.is_deleted}
missing_rooms = [(room_id, room_name) for room_id, room_name in missing_rooms
if room_id in favorites]
rooms = sorted(rooms + missing_rooms, key=lambda room: natural_sort_key(room[1]))
return rooms
class RHRoomBlockings(RHRoomBookingBase):
@use_kwargs({
'timeframe': fields.Str(),
'my_rooms': fields.Bool(),
'mine': fields.Bool()
})
def _process(self, timeframe, my_rooms, mine):
filters = {'timeframe': timeframe, 'created_by': session.user if mine else None,
'in_rooms_owned_by': session.user if my_rooms else None}
blockings = get_room_blockings(**filters)
return jsonify(blockings_schema.dump(blockings).data)
class RHSearchRooms(RHRoomBookingBase):
@use_args(
dict(
search_room_args, **{
'unavailable': fields.Bool(missing=False),
'admin_override_enabled': fields.Bool(missing=False)
}))
def _process(self, args):
filter_availability = all(x in args for x in ('start_dt', 'end_dt',
'repeat_frequency',
'repeat_interval'))
only_unavailable = args.pop('unavailable')
admin_override_enabled = args.pop('admin_override_enabled')
if not filter_availability:
availability = None
if only_unavailable:
raise UnprocessableEntity(
'Required data to filter by availability is not present')
else:
availability = not only_unavailable
search_query = search_for_rooms(args,
allow_admin=admin_override_enabled,
availability=availability)
room_ids = [id_ for id_, in search_query.with_entities(Room.id)]
if filter_availability:
room_ids_without_availability_filter = [
id_ for id_, in search_for_rooms(
args, allow_admin=admin_override_enabled).with_entities(
Room.id)
]
else:
room_ids_without_availability_filter = room_ids
return jsonify(rooms=room_ids,
rooms_without_availability_filter=
room_ids_without_availability_filter,
total=len(room_ids_without_availability_filter),
availability_days=self._get_date_range(args))
def _get_date_range(self, filters):
try:
start_dt, end_dt = filters['start_dt'], filters['end_dt']
repetition = filters['repeat_frequency'], filters[
'repeat_interval']
except KeyError:
return None
return [
dt.date().isoformat()
for dt in ReservationOccurrence.iter_start_time(
start_dt, end_dt, repetition)
]
class CommunityUpdateAPI(HTTPEndpoint):
@use_args({"demos": fields.Bool(), "community_type": fields.Str(),
"match_start_webhook": fields.Str(min=5, max=255),
"round_end_webhook": fields.Str(min=5, max=255),
"match_end_webhook": fields.Str(min=5, max=255),
"allow_api_access": fields.Bool(),
"email": fields.Str(max=255)})
@requires("is_owner")
async def post(self, request: Request, parameters: dict) -> response:
await request.state.community.update(**parameters)
await (CommunityCache(request.state.community.community_name)).expire()
return response()
class PlayersSchema(Schema):
name = fields.Str(min=1, max=42, required=True)
steam_id = fields.Str(min=64, max=64)
team = fields.Int(required=True)
alive = fields.Bool(required=True)
ping = fields.Int(required=True)
kills = fields.Int(required=True)
headshots = fields.Int(required=True)
assists = fields.Int(required=True)
deaths = fields.Int(required=True)
shots_fired = fields.Int(required=True)
shots_hit = fields.Int(required=True)
mvps = fields.Int(required=True)
score = fields.Int(required=True)
disconnected = fields.Bool(required=True)
class RequestSchema:
# BIN creation v2
BinV2POST = {
"creator": fields.Str(
required=True, validate=validate.Regexp("([0-9a-zA-Z .@_-]){2,60}")
),
"title": fields.Str(
required=True, validate=validate.Regexp("([0-9a-zA-Z .@_-]){1,60}")
),
"data": fields.Str(required=True),
"private": fields.Bool(required=True),
"language": fields.Str(required=True)
}
BinV2GET = {
"slug": fields.Str(
required=True, validate=validate.Regexp("([0-9a-zA-Z .@_-]){2,60}")
),
}
BinLikes = {
"slug": fields.Str(
required=True, validate=validate.Regexp("([0-9a-zA-Z .@_-]){2,60}")
)
}
BinViews = {
"slug": fields.Str(
required=True, validate=validate.Regexp("([0-9a-zA-Z .@_-]){2,60}")
)
}
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
class RHUploadBackgroundImage(RHModifyDesignerTemplateBase):
@use_kwargs({'background': fields.Bool(load_default=False)},
location='query')
def _process(self, background):
f = request.files['file']
filename = secure_filename(f.filename, 'image')
data = BytesIO()
shutil.copyfileobj(f, data)
data.seek(0)
try:
image_type = Image.open(data).format.lower()
except OSError:
# Invalid image data
return jsonify(error='Invalid image data!')
data.seek(0)
if image_type not in {'jpeg', 'gif', 'png'}:
return jsonify(error='File format not accepted!')
content_type = 'image/' + image_type
image = DesignerImageFile(template=self.template,
filename=filename,
content_type=content_type)
if background:
self.template.background_image = image
image.save(data)
flash(_('The image has been uploaded'), 'success')
return jsonify_data(image_id=image.id, image_url=image.download_url)
class FamilyTogethernessSchemeResource(Resource):
grant_args = {
'has_husband_wife': fields.Bool(required=True),
'age_limit': fields.Int(required=True),
}
@use_args(grant_args, location='query')
def get(self, args):
""" List households and qualifying family members for Family Togetherness Bonus
-Household with husband and wife
-Has children younger than 18 years old
"""
family_members_list = []
data = []
age_limit_param = args['age_limit']
has_husband_wife = args['has_husband_wife']
# convert age limit to datetime object
date_limit = datetime.date.today(
) - dateutil.relativedelta.relativedelta(years=int(age_limit_param))
# query to select members below age limit
children_sub_q = FamilyMember.query.with_entities(FamilyMember.household_id).filter(
FamilyMember.dob > date_limit).group_by(FamilyMember.household_id)
# query to select husband and wife
spouse_sub_q = FamilyMember.query.with_entities(FamilyMember.household_id).filter(
FamilyMember.spouse_name != None).group_by(FamilyMember.household_id).having(func.count(
FamilyMember.spouse_name) > 1)
# query to exclude non-married members older than age limit
older_sub_q = FamilyMember.query.with_entities(
FamilyMember.name).filter((FamilyMember.dob <= date_limit) & FamilyMember.spouse_name == None)
if has_husband_wife:
query_result = FamilyMember.query.filter(
FamilyMember.household_id.in_(children_sub_q) & FamilyMember.household_id.in_(spouse_sub_q) & ~FamilyMember.name.in_(older_sub_q))
for x in query_result:
result_dict = x.__dict__
result_dict.pop('_sa_instance_state', None)
data.append(result_dict)
# group qualifying members based on household id
data = sorted(data, key=operator.itemgetter("household_id"))
outputList = []
for i, g in itertools.groupby(data, key=operator.itemgetter("household_id")):
outputList.append(list(g))
household_list = generateFamilyMembersDict(outputList)
return (
{
"data": household_list
},
HTTPStatus.OK,
)
def make_sort_args(default=None, validator=None, default_hide_null=False, default_reverse_nulls=True, default_nulls_only=False):
return {
'sort': fields.Str(
missing=default,
validate=validator,
description='Provide a field to sort by. Use - for descending order.',
),
'sort_hide_null': fields.Bool(
missing=default_hide_null,
description='Hide null values on sorted column(s).'
),
'sort_null_only': fields.Bool(
missing=default_nulls_only,
description='Toggle that filters out all rows having sort column that is non-null'
)
}
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 _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 get_dbs(
cls, admin=None, active=None, verified=None, permissions=None, **kwargs
):
args = parser.parse({
'admin': wf.Bool(missing=None),
'active': wf.Bool(missing=None),
'verified': wf.Bool(missing=None),
'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
})
return super(User, cls).get_dbs(
admin=admin or args['admin'],
active=active or args['active'],
verified=verified or args['verified'],
permissions=permissions or args['permissions'],
**kwargs
)
class RHDisconnectService(RHEditingManagementBase):
"""Disconnect the event from the editing workflow service."""
@use_kwargs({
'force': fields.Bool(missing=False),
})
def _process(self, force):
if not editing_settings.get(self.event, 'service_url'):
raise BadRequest('Service URL not set')
status = service_get_status(self.event)
notify_service = True
if status['error']:
if not force:
# this only happens if the service went down between loading
# the page and sending the disconnect request
raise BadRequest('Cannot disconnect service')
notify_service = False
elif not status['status']['can_disconnect']:
raise BadRequest('Cannot disconnect service')
if notify_service:
try:
service_handle_disconnected(self.event)
except ServiceRequestFailed as exc:
raise ServiceUnavailable(
_('Could not disconnect event from service: {}').format(
exc))
editing_settings.delete(self.event, 'service_url', 'service_token')
return '', 204
class RHRegistrationFormCheckEmail(RHRegistrationFormBase):
"""Check how an email will affect the registration."""
ALLOW_PROTECTED_EVENT = True
@use_kwargs({
'email': fields.String(required=True),
'update': UUIDString(load_default=None),
'management': fields.Bool(load_default=False),
}, location='query')
def _process_args(self, email, update, management):
RHRegistrationFormBase._process_args(self)
self.email = email.lower()
self.update = update
self.management = management
self.existing_registration = self.regform.get_registration(uuid=self.update) if self.update else None
def _check_access(self):
if not self.existing_registration:
RHRegistrationFormBase._check_access(self)
def _process(self):
if self.update:
return jsonify(check_registration_email(self.regform, self.email, self.existing_registration,
management=self.management))
else:
return jsonify(check_registration_email(self.regform, self.email, management=self.management))
def _cleanup(self, override_lock: fields.Bool(missing=False)) -> None:
benji_obj = None
try:
benji_obj = Benji(self._config)
benji_obj.cleanup(override_lock=override_lock)
finally:
if benji_obj:
benji_obj.close()
class RHRoomBlockings(RHRoomBookingBase):
@use_kwargs({
'start_dt': fields.Date(),
'end_dt': fields.Date(),
'blockings_in_my_rooms': fields.Bool(),
'my_blockings': fields.Bool()
})
def _process(self, start_dt, end_dt, blockings_in_my_rooms, my_blockings):
filters = {
'start_dt': start_dt,
'end_dt': end_dt,
'created_by': session.user if my_blockings else None,
'in_rooms_owned_by':
session.user if blockings_in_my_rooms else None
}
blockings = get_room_blockings(**filters)
return jsonify(blockings_schema.dump(blockings).data)
class RHGroupSearch(RHProtected):
@use_kwargs({
'name': fields.Str(required=True),
'exact': fields.Bool(missing=False),
})
def _process(self, name, exact):
groups = GroupProxy.search(name, exact=exact)
total = len(groups)
return jsonify(groups=[serialize_group(group) for group in groups[:10]], total=total)
class UserSchema(ModelSchema):
is_admin = fields.Bool()
publisher = fields.Nested(
lambda: PublisherSchema(only=('id', 'name')),
many=False,
)
class Meta:
model = User
exclude = ['password']
class PlayerTitlesFinals(Resource):
args = {
'singles': fields.Bool(missing=True),
'years': fields.Str(missing="*")
}
@use_kwargs(args)
def get(self, name, singles, years):
name = parse_player_name(name)
return parse_player_titles_page(name, singles, years)
def _api_v1_versions_metadata_backup_create(
self, filter_expression: fields.Str(missing=None),
force: fields.Bool(missing=False)
) -> None:
with Benji(self._config) as benji_obj:
version_uid_objs = [
version.uid for version in benji_obj.find_versions_with_filter(
filter_expression)
]
benji_obj.metadata_backup(version_uid_objs, overwrite=force)
