def get_administrators(page=1, limit=10):
"""Retrieves a list of administrators
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of administrators; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Administrator, Administrator.id.asc(), {
'id.asc': Administrator.id.asc(),
'id.desc': Administrator.id.desc(),
'username.asc': Administrator.username.asc(),
'username.desc': Administrator.username.desc(),
'joined_at.asc': Administrator.joined_at.asc(),
'joined_at.desc': Administrator.joined_at.desc(),
'created_at.asc': Administrator.created_at.asc(),
'created_at.desc': Administrator.created_at.desc(),
'updated_at.asc': Administrator.updated_at.asc(),
'updated_at.desc': Administrator.updated_at.desc(),
}, request.args, Query.STATUS_FILTER_ADMIN)
# filter query based on URL parameters
if request.args.get('role', '').isnumeric():
query = query.filter(
Administrator.roles.any(Role.id == int(request.args.get('role'))))
if request.args.get('username', None) is not None:
query = query.filter(
Administrator.username.ilike('%' + request.args.get('username') +
'%'))
if request.args.get('email', None) is not None:
temp_user = Administrator(email=request.args.get('email'))
query = query.filter(
Administrator.email_digest == temp_user.email_digest)
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'administrators':
AdministratorAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_administrators.get_administrators', page,
limit, output['total'], request.args))
return jsonify(output), 200
return '', 204
def get_roles(page=1, limit=10, role_type=None):
"""Retrieves a list of roles.
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:param role_type: Type of role to filter by: `admin` | `user`
:type role_type: str
:returns: JSON string of list of roles; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Role, Role.id.asc(), {
'id.asc': Role.id.asc(),
'id.desc': Role.id.desc(),
'name.asc': Role.name.asc(),
'name.desc': Role.name.desc(),
'created_at.asc': Role.created_at.asc(),
'created_at.desc': Role.created_at.desc(),
'updated_at.asc': Role.updated_at.asc(),
'updated_at.desc': Role.updated_at.desc(),
}, request.args, Query.STATUS_FILTER_NONE)
# filter query based on URL parameters
if role_type in ['admin', 'user']:
query = query.filter(Role.is_admin_role == bool(role_type == 'admin'))
if request.args.get('name', None) is not None:
query = query.filter(
Role.name.ilike('%' + request.args.get('name') + '%'))
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'roles': RoleAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_roles.get_roles',
page,
limit,
output['total'],
request.args,
role_type=role_type))
return jsonify(output), 200
return '', 204
def get_logins(page=1, limit=25):
"""Retrieves a list of logins.
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of logins; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Login, Login.id.asc(), {
'id.asc': Login.id.asc(),
'id.desc': Login.id.desc(),
'attempt_date.asc': Login.attempt_date.asc(),
'attempt_date.desc': Login.attempt_date.desc(),
}, request.args, Query.STATUS_FILTER_NONE)
# filter query based on URL parameters
if request.args.get('user_id', None) is not None:
query = query.filter(Login.user_id == request.args.get('user_id'))
if request.args.get('username', None) is not None:
query = query.filter(
Login.username.ilike('%' + request.args.get('username') + '%'))
if request.args.get('ip_address', None) is not None:
query = query.filter(
Login.ip_address.ilike('%' + request.args.get('ip_address') + '%'))
if request.args.get('api', None) is not None:
query = query.filter(Login.api.in_(request.args.get('api').split(',')))
if request.args.get('success', None) is not None:
query = query.filter(
Login.success.in_(request.args.get('success').split(',')))
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'logins': LoginAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_logins.get_logins', page, limit,
output['total'], request.args))
return jsonify(output), 200
return '', 204
def get_app_keys(page=1, limit=10):
"""Retrieves a list of application keys
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of application keys; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
AppKey, AppKey.id.asc(), {
'id.asc': AppKey.id.asc(),
'id.desc': AppKey.id.desc(),
'application.asc': AppKey.application.asc(),
'application.desc': AppKey.application.desc(),
'created_at.asc': AppKey.created_at.asc(),
'created_at.desc': AppKey.created_at.desc(),
'updated_at.asc': AppKey.updated_at.asc(),
'updated_at.desc': AppKey.updated_at.desc(),
}, request.args, Query.STATUS_FILTER_ADMIN)
# filter query based on URL parameters
if request.args.get('application', None) is not None:
query = query.filter(
AppKey.application.ilike('%' + request.args.get('application') +
'%'))
if request.args.get('key', None) is not None:
query = query.filter(
AppKey.key.ilike('%' + request.args.get('key') + '%'))
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'app_keys': AppKeyAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_app_keys.get_app_keys', page, limit,
output['total'], request.args))
return jsonify(output), 200
return '', 204
def get_notifications(page=1, limit=10):
"""Retrieves a list of notifications.
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of notifications; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Notification,
Notification.id.asc(),
{
'id.asc': Notification.id.asc(),
'id.desc': Notification.id.desc(),
'sent_at.asc': Notification.sent_at.asc(),
'sent_at.desc': Notification.sent_at.desc(),
},
request.args,
Query.STATUS_FILTER_ADMIN)
# filter query based on URL parameters
if request.args.get('user_id', None) is not None:
query = query.filter(
Notification.user_id == request.args.get('user_id'))
if request.args.get('channel', None) is not None:
query = query.filter(
Notification.channel == request.args.get('channel'))
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'notifications': NotificationAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_notifications.get_notifications', page,
limit, output['total'], request.args))
return jsonify(output), 200
return '', 204
def test_pager_get_uris(app):
with app.app_context():
# mock a route
def mock_path(page=1, limit=10):
pass
public = Blueprint('pager_test', __name__)
public.route("/mock_path/<int:page>/<int:limit>",
methods=['GET'])(mock_path)
app.register_blueprint(public)
# single page of results
assert Pager.get_uris('pager_test.mock_path', 1, 20, 10, {}) == {}
# first page of results
assert Pager.get_uris('pager_test.mock_path', 1, 10, 50, {}) == {
'next_uri': 'http://localhost/mock_path/2/10'
}
# second page of results
assert Pager.get_uris('pager_test.mock_path', 2, 15, 50, {}) == {
'previous_uri': 'http://localhost/mock_path/1/15',
'next_uri': 'http://localhost/mock_path/3/15'
}
# last page of results
assert Pager.get_uris('pager_test.mock_path', 5, 10, 50, {}) == {
'previous_uri': 'http://localhost/mock_path/4/10'
}
# first page of results with args
assert Pager.get_uris('pager_test.mock_path', 1, 10, 50,
{'foo': 'bar'}) == {
'next_uri':
'http://localhost/mock_path/2/10?foo=bar'
}
# second page of results with args
assert Pager.get_uris('pager_test.mock_path', 2, 15, 50,
{'foo': 'bar'}) == {
'previous_uri':
'http://localhost/mock_path/1/15?foo=bar',
'next_uri':
'http://localhost/mock_path/3/15?foo=bar'
}
# last page of results with args
assert Pager.get_uris('pager_test.mock_path', 5, 10, 50,
{'foo': 'bar'}) == {
'previous_uri':
'http://localhost/mock_path/4/10?foo=bar'
}
def get_regions(country_code, page=1, limit=100):
"""Retrieves a list of regions (states).
:param country_code: The two character country code to filter regions by
:type country_code: str
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of regions; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Region,
Region.name.asc(),
{
'id.asc': Region.id.asc(),
'id.desc': Region.id.desc(),
'name.asc': Region.name.asc(),
'name.desc': Region.name.desc(),
'code_2.asc': Region.code_2.asc(),
'code_2.desc': Region.code_2.desc(),
},
request.args,
Query.STATUS_FILTER_USER)
query = query.filter(Region.country.has(code_2=country_code))
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'regions': RegionSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('public_locations.get_regions', page, limit,
output['total'], request.args,
country_code=country_code))
return jsonify(output), 200
return '', 204
def get_countries(page=1, limit=250):
"""Retrieves a list of countries.
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of countries; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
Country,
Country.name.asc(),
{
'id.asc': Country.id.asc(),
'id.desc': Country.id.desc(),
'name.asc': Country.name.asc(),
'name.desc': Country.name.desc(),
'code_2.asc': Country.code_2.asc(),
'code_2.desc': Country.code_2.desc(),
'code_3.asc': Country.code_3.asc(),
'code_3.desc': Country.code_3.desc(),
},
request.args,
Query.STATUS_FILTER_USER)
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'countries': CountrySchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(Pager.get_uris('public_locations.get_countries', page,
limit, output['total'], request.args))
return jsonify(output), 200
return '', 204
def get_terms_of_services(page=1, limit=10):
"""Retrieves a list of terms of service.
:param page: Page number
:type page: int
:param limit: Maximum number of results to show
:type limit: int
:returns: JSON string of list of terms of service; status code
:rtype: (str, int)
"""
# initialize query
query = Query.make(
TermsOfService, TermsOfService.id.asc(), {
'id.asc': TermsOfService.id.asc(),
'id.desc': TermsOfService.id.desc(),
'publish_date.asc': TermsOfService.publish_date.asc(),
'publish_date.desc': TermsOfService.publish_date.desc(),
'version.asc': TermsOfService.version.asc(),
'version.desc': TermsOfService.version.desc(),
'created_at.asc': TermsOfService.created_at.asc(),
'created_at.desc': TermsOfService.created_at.desc(),
'updated_at.asc': TermsOfService.updated_at.asc(),
'updated_at.desc': TermsOfService.updated_at.desc(),
}, request.args, Query.STATUS_FILTER_ADMIN)
# retrieve and return results
results = list(query.limit(limit).offset((page - 1) * limit))
if len(results) > 0:
# prep initial output
output = {
'terms_of_services':
TermsOfServiceAdminSchema(many=True).dump(results),
'page': page,
'limit': limit,
'total': query.count()
}
# add pagination URIs and return
output.update(
Pager.get_uris('admin_terms_of_services.get_terms_of_services',
page, limit, output['total'], request.args))
return jsonify(output), 200
return '', 204