def _get_okta_groups(api_client):
"""
Get groups from Okta server
:param api_client: Okta api client
:return: Array of group information
"""
group_list = []
next_url = None
# SDK Bug
# get_paged_groups returns User object instead of UserGroup
while True:
# https://developer.okta.com/docs/reference/api/groups/#list-groups
if next_url:
paged_response = api_client.get(next_url)
else:
params = {
'limit': 10000,
}
paged_response = api_client.get_path('/', params)
paged_results = PagedResults(paged_response, UserGroup)
group_list.extend(paged_results.result)
if not is_last_page(paged_response):
next_url = paged_response.links.get("next").get("url")
else:
break
return group_list
def get_paged_groups(self,
limit=None,
filter_string=None,
after=None,
url=None):
"""Get a paged list of UserGroups
:param limit: maximum number of groups to return
:type limit: int or None
:param filter_string: Filter expression for groups
:type filter_string: str or None
:param after: group id that filtering will resume after
:type after: str
:param url: url that returns a list of UserGroup
:type url: str
:rtype: PagedResults of UserGroup
"""
if url:
response = self.get(url)
else:
params = {'limit': limit, 'filter': filter_string, 'after': after}
response = self.get_path('/', params=params)
return PagedResults(response, UserGroup)
def get_paged_users(self,
limit=None,
filter_string=None,
search_string=None,
after=None,
url=None):
"""Get a paged list of Users
:param limit: maximum number of users to return
:type limit: int or None
:param filter_string: string to filter users
:type filter_string: str or None
:param search_string: string to search users
:type search_string: str or None
:param after: user id that filtering will resume after
:type after: str
:param url: url that returns a list of User
:type url: str
:rtype: PagedResults of User
"""
if url:
response = ApiClient.get(self, url)
else:
params = {
'limit': limit,
'after': after,
'filter': filter_string,
'search': search_string
}
response = ApiClient.get_path(self, '/', params=params)
return PagedResults(response, self.user_model)
def get_paged_events(self,
limit=None,
start_date=None,
after=None,
filter_string=None,
url=None):
"""Get a paged list of Events
:param limit: maximum number of events to return
:type limit: int or None
:param filter_string: string to filter events
:type filter_string: str or None
:param after: event id that filtering will resume after
:type after: str or None
:param url: url that returns a list of Event
:type url: str or None
:rtype: PagedResults of Event
"""
if url:
response = ApiClient.get(self, url)
else:
params = {
'limit': limit,
'startDate': start_date,
'after': after,
'filter': filter_string
}
response = ApiClient.get_path(self, '/', params=params)
return PagedResults(response, Event)
def get_paged_app_instances(self,
limit=None,
filter_string=None,
after=None,
url=None):
"""Get a paged list of AppInstances
:param limit: maximum number of apps to return
:type limit: int or None
:param filter_string: string to filter apps
:type filter_string: str or None
:param after: app id that filtering will resume after
:type after: str
:param url: url that returns a list of AppInstance
:type url: str
:rtype: PagedResults of AppInstance
"""
if url:
response = ApiClient.get(self, url)
else:
params = {'limit': limit, 'after': after, 'filter': filter_string}
response = ApiClient.get_path(self, '/', params=params)
return PagedResults(response, AppInstance)
def get_paged_apps_assigned_to_group(self,
gid,
url=None,
limit=None,
after=None):
if url:
response = self.get(url)
else:
params = {'limit': limit, 'after': after}
response = self.get_path('/{0}/apps'.format(gid), params=params)
return PagedResults(response, AppInstance)
def get_paged_groups(self, limit=None, after=None, url=None):
"""Get a paged list of UserGroups
:param limit: maximum number of groups to return
:type limit: int or None
:param after: group id that filtering will resume after
:type after: str
:param url: url that returns a list of UserGroup
:type url: str
:rtype: PagedResults of UserGroup
"""
if url:
response = ApiClient.get(self, url)
else:
params = {'limit': limit, 'after': after}
response = ApiClient.get_path(self, '/', params=params)
return PagedResults(response, User)
def get_paged_group_members(self, gid, url=None, limit=None, after=None):
"""Get a paged list of users from a group
:param gid: the group id
:type gid: str
:param limit: maximum number of users to return
:type limit: int or None
:param after: user id that filtering will resume after
:type after: str
:param url: url that returns a list of User
:type url: str
:rtype: PagedResults of User
"""
if url:
response = self.get(url)
else:
params = {'limit': limit, 'after': after}
response = self.get_path('/{0}/users'.format(gid), params=params)
return PagedResults(response, User)
def get_paged_group_targets_for_user_admin(self, uid, rid, url=None, limit=None):
"""Get a paged list of group targets for an USER_ADMIN role assignment
:param uid: the user id
:type uid: str
:param rid: the USER_ADMIN role id
:type rid: str
:param url: url that returns a list of group targets
:type url: str
:param limit: maximum number of Group to return
:type limit: int or None
:rtype: Array of UserGroup
"""
if url:
response = ApiClient.get(self, url)
else:
params = {
'limit': limit
}
url_path = '/{0}/roles/{1}/targets/groups'.format(uid, rid)
response = ApiClient.get_path(self, url_path, params=params)
return PagedResults(response, UserGroup)
def get_paged_app_targets_for_app_admin(self, uid, rid, url=None, limit=None):
"""Get a paged list of app targets for an APP_ADMIN role assignment
:param uid: the user id
:type uid: str
:param rid: the APP_ADMIN role id
:type rid: str
:param url: url that returns a list of app targets
:type url: str
:param limit: maximum number of Apps to return
:type limit: int or None
:rtype: Array of CatalogApp
"""
if url:
response = ApiClient.get(self, url)
else:
params = {
'limit': limit
}
url_path = '/{0}/roles/{1}/targets/catalog/apps'.format(uid, rid)
response = ApiClient.get_path(self, url_path, params=params)
# TODO: create Catalog App Model
return PagedResults(response, AppInstance)
def get_paged_log_events(self, since=None, until=None, q=None, filter=None, limit=None, url=None):
"""Get a paged list of log events
:param since: filters the lower time bound of the log events published property
:type since: datetime or None
:param until: filters the upper time bound of the log events published property
:type until: datetime or None
:param filter: filter expression that filters the results
:type filter: str or None
:param q: filters the log events results by one or more exact keywords
:type q: str or None
:rtype: list of dictionaries representing log events
:param limit: The number of results returned in the response
:type limit: int or None
:param url: url that returns a list of log events
:type url: str
:rtype: PagedResults of log events in JSON format
"""
if url: # pragma: no cover
assert since is None
assert until is None
assert q is None
assert filter is None
assert limit is None
warnings.warn("Don't pass `url`, use `get_next_page` method instead", DeprecationWarning)
return self.get_next_page(url)
params = {
'since': since,
'until': until,
'q': q,
'filter': filter,
'limit': limit,
}
response = self.get_path('/', params=params)
return PagedResults(response)
def get_next_page(self, url):
return PagedResults(self.get(url))
