Python ApiClient.get_path方法代码示例

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    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)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_paged_users(self, limit=None, filter_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 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
            }
            response = ApiClient.get_path(self, '/', params=params)

        return PagedResults(response, User)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def validate_session(self, id):
        """Validate a session

        :param id: the target session id
        :rtype: Session
        """
        response = ApiClient.get_path(self, '/{0}'.format(id))
        return Utils.deserialize(response.text, Session)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_app_instance(self, id):
        """Get a single app

        :param id: the app id
        :type id: str
        :rtype: AppInstance
        """
        response = ApiClient.get_path(self, '/{0}'.format(id))
        return Utils.deserialize(response.text, AppInstance)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_group_users(self, gid):
        """Get the users of a group

        :param gid: the group id
        :type gid: str
        :rtype: User
        """
        response = ApiClient.get_path(self, '/{0}/users'.format(gid))
        return Utils.deserialize(response.text, User)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_factors_catalog(self, user_id):
        """Get available factors for a user

        :param user_id: target user id
        :type user_id: str
        :rtype: list of FactorCatalogEntry
        """
        response = ApiClient.get_path(self, '/{0}/factors/catalog'.format(user_id))
        return Utils.deserialize(response.text, FactorCatalogEntry)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_available_questions(self, user_id):
        """Get available factor questions

        :param user_id: target user id
        :type user_id: str
        :rtype: list of Question
        """
        response = ApiClient.get_path(self, '/{0}/factors/questions'.format(user_id))
        return Utils.deserialize(response.text, Question)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_group(self, gid):
        """Get a single group

        :param gid: the group id
        :type gid: str
        :rtype: UserGroup
        """
        response = ApiClient.get_path(self, '/{0}'.format(gid))
        return Utils.deserialize(response.text, UserGroup)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_user_applinks(self, uid):
        """Get applinks of a single user

        :param uid: the user id or login
        :type uid: str
        :rtype: AppLinks
        """
        response = ApiClient.get_path(self, '/{0}/appLinks'.format(uid))
        return Utils.deserialize(response.text, AppLinks)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_lifecycle_factors(self, user_id):
        """Get enrolled factors for a user

        :param user_id: target user id
        :type user_id: str
        :rtype: list of Factor
        """
        response = ApiClient.get_path(self, '/{0}/factors'.format(user_id))
        return Utils.deserialize(response.text, Factor)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_user(self, uid):
        """Get a single user

        :param uid: the user id or login
        :type uid: str
        :rtype: User
        """
        response = ApiClient.get_path(self, '/{0}'.format(uid))
        return Utils.deserialize(response.text, User)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_factor(self, user_id, user_factor_id):
        """Get information about an enrolled factor

        :param user_id: target user id
        :type user_id: str
        :param user_factor_id: target factor id
        :type user_factor_id: str
        :rtype: Factor
        """
        response = ApiClient.get_path(self, '/{0}/factors/{1}'.format(user_id, user_factor_id))
        return Utils.deserialize(response.text, Factor)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_org_factors(self, filter_string=None):
        """Get a list of OrgAuthFactors

        :param filter_string: string to filter factors
        :type filter_string: str or None
        :rtype: list of OrgAuthFactor
        """
        params = {
            'filter': filter_string
        }
        response = ApiClient.get_path(self, '/factors', params=params)
        return Utils.deserialize(response.text, OrgAuthFactor)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_factor_device(self, user_id, user_factor_id, device_id):
        """Get a factor device for a user

        :param user_id: target user id
        :type user_id: str
        :param user_factor_id: target factor id
        :type user_factor_id: str
        :param device_id: target factor device id
        :type device_id: str
        :rtype: FactorDevice
        """
        response = ApiClient.get_path(self, '/{0}/factors/{1}/device/{2}'.format(user_id, user_factor_id, device_id))
        return Utils.deserialize(response.text, FactorDevice)

# 需要导入模块: from okta.framework.ApiClient import ApiClient [as 别名]
# 或者: from okta.framework.ApiClient.ApiClient import get_path [as 别名]
    def get_groups(self, limit=None, query=None):
        """Get a list of UserGroups

        :param limit: maximum number of groups to return
        :type limit: int or None
        :param query: string to search group names
        :type query: str or None
        :rtype: list of UserGroup
        """
        params = {
            'limit': limit,
            'q': query
        }
        response = ApiClient.get_path(self, '/', params=params)
        return Utils.deserialize(response.text, UserGroup)