Python RestApiClient.call_api方法代码示例

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    
    # Create our client and set up some sample data.
    client = RestApiClient()
    setup_data(client)
    
    # Some endpoints accept body parameters. An example of this is the
    # /referencedata/sets/bulkLoad endpoint.
    # Body parameters may appear with path parameters, as in this case, but will
    # never appear with query parameters.
    
    # You must make sure that you set the content type correctly to a type
    # accepted by the endpoint.
    headers = client.get_headers().copy()
    headers['Content-type'] = 'application/json'
    
    body = b'["abc", "def", "123"]'
    
    # Send the request.
    SampleUtilities.pretty_print_request(client, 'referencedata/sets/bulkLoad/rest_api_samples_testset', 'POST', headers=headers)
    response = client.call_api('referencedata/sets/bulkLoad/rest_api_samples_testset', 'POST', headers=headers, data=body)
    SampleUtilities.pretty_print_response(response)
    
    # The response from the previous command only shows information about the
    # set, not the contents of the set. We can view the contents of the set with
    # this command:
    response = client.call_api('referencedata/sets/rest_api_samples_testset', 'GET')
    SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():

    # Create our client and set up some sample data.
    client = RestApiClient()
    setup_data(client)
    
    # Some endpoints accept path parameters.
    # These parameters are inserted into the path portion of the URL at specific
    # locations. In this example we are retrieving the contents of a reference
    # set named 'rest_api_samples_testset'.
    SampleUtilities.pretty_print_request(client, 'referencedata/sets/rest_api_samples_testset', 'GET')
    response = client.call_api('referencedata/sets/rest_api_samples_testset', 'GET')
    SampleUtilities.pretty_print_response(response)
    
    
    # Query parameters and path parameters can be combined in a single request.
    # Here we are adding a value to the reference set we just looked at.
    SampleUtilities.pretty_print_request(client, 'referencedata/sets/rest_api_samples_testset?value=rest_api_sample_value', 'POST')
    response = client.call_api('referencedata/sets/rest_api_samples_testset?value=rest_api_sample_value', 'POST')
    
    # Along with GET requests, POST and DELETE requests often return information
    # that can be used to confirm the results of the request.
    SampleUtilities.pretty_print_response(response)
    
    # Now we can look at the contents of the reference set again to see the
    # value we added.
    response = client.call_api('referencedata/sets/rest_api_samples_testset', 'GET')
    SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client and set up some sample data.
    client = RestApiClient()
    setup_data(client)
    
    # Here we have a look at the data in this map of sets.
    response = client.call_api('referencedata/mapOfSets/rest_api_samples_login_events', 'GET')
    SampleUtilities.pretty_print_response(response)
    
    # Retrieve the map of sets and load it into a JSON object.
    response = client.call_api('referencedata/mapOfSets/rest_api_samples_login_events', 'GET')
    response_body = json.loads(response.read().decode('utf-8'))
    
    # Capture the data portion of the map of sets.
    data = response_body['data']
    
    # Also get the current time so that the CIO's dashboard can plot the results
    # over time.
    current_time = time.strftime('%Y-%m-%d %H:%M:%S')
    
    # We now empty the reference map of sets so that new data can start to
    # accumulate. We empty it now so that we don't miss new events if we have a
    # lot of data to process. Note that by using the purgeOnly parameter we are
    # only emptying the collection, not deleting it.
    print("Purging the collection so that new data can be collected.")
    response = client.call_api('referencedata/mapOfSets/rest_api_samples_login_events?purgeOnly=true', 'DELETE')
    SampleUtilities.pretty_print_response(response)
    
    # Go through the data, find the information we are interested in, and send
    # it to the CIO's dashboard.
    for key in data.keys():
        number_of_elements = len(data[key])
        send_data_to_dashboard(current_time, key, number_of_elements)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client.
    client = RestApiClient()
    
    # While using the REST API an error may occur. Information about
    # the error is returned to you in the HTTP response that you receive.
    # The HTTP code in the response can tell you a little bit about the error.
    # A code in the 400 range indicates that there was a problem with the
    # request.
    # A code in the 500 range indicates that there was a problem with the
    # server.
    # In addition to the response code, the response body contains information
    # about the error that occurred.
    
    # In this example we are trying to access the contents of a reference data
    # set that does not exist.
    try:
        SampleUtilities.pretty_print_request(client, 'referencedata/sets/rest_api_samples_does_not_exist', 'GET')
        response = client.call_api('referencedata/sets/rest_api_samples_does_not_exist', 'GET')
    except urllib.error.HTTPError as e:
        response = e
    
    SampleUtilities.pretty_print_response(response)
    
    # In this example we are passing a query parameter using the wrong name.
    try:
        SampleUtilities.pretty_print_request(client, 'referencedata/sets?wrong_name=fake', 'POST')
        response = client.call_api('referencedata/sets?wrong_name=fake', 'POST')
    except urllib.error.HTTPError as e:
        response = e
        
    SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # For the purpose of this sample, the reading in of credentials, the setup
    # of HTTP request headers, and the construction and sending of a request
    # object has been abstracted to the 'RestApiClient' class.
    # For more information on how these operations are done see the sample
    # '01_Authentication.py'.
    client = RestApiClient()

    # Many API endpoints accept parameters.
    # One type of parameter is a query parameter.
    # If an endpoint accepts query parameters they are passed after a '?' as
    # part of the URL. Each parameter has a name and a value separated by a '='.
    # Several parameters can be passed separated by '&' characters.
    SampleUtilities.pretty_print_request(client, 'reference_data/sets?name=rest_api_samples_testset&element_type=ALN', 'POST')

    response = client.call_api('reference_data/sets?name=rest_api_samples_testset&element_type=ALN', 'POST')

    # The response code for successfully creating a set is 201.
    if (response.code == 201):
        SampleUtilities.pretty_print_response(response)
    # The error code that occurs when attempting to create a set that already
    # exists is 409.
    elif (response.code == 409):
        print("Reference set already exists")
        response = client.call_api('reference_data/sets/rest_api_samples_testset', 'GET')
        SampleUtilities.pretty_print_response(response)
    elif (response.code >= 500):
        print("An internal server error occurred. You should check your system.")
        SampleUtilities.pretty_print_response(response)
    else:
        print("Some other error has occurred:")
        SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
	# First we have to create our client
	client = RestApiClient()

	# Request the API call only taking a few fields
	SampleUtilities.pretty_print_request(client, 'siem/offenses?fields=id,description,' +
		'status,offense_type,offense_source', 'GET')
	response = client.call_api('siem/offenses?fields=id,description,status,offense_type,offense_source', 'GET')

	# Print out the result for the user to see
	SampleUtilities.pretty_print_response(response)

	# Prompt the user for an ID
	offense_ID = input('Select an offense to post a note to. Please type its ID or quit. ')
	
	# Error checking because we want to make sure the user has selected an offense that exists.
	while True:

		if (offense_ID == 'quit'):
			exit(0)

		# Make the request to 'GET' the offense chosen by the user
		SampleUtilities.pretty_print_request(client, 'siem/offenses/' + str(offense_ID), 'GET')
		response = client.call_api('siem/offenses/' + str(offense_ID), 'GET')

		# Check response code to see if the offense exists
		if (response.code == 200):
			break
		else:
			offense_ID = input('An offense by that ID does not exist. Please try again or type quit. ')

	# Print out the offense the user chose
	SampleUtilities.pretty_print_response(response)

	# Send in the API Call request for the offense's notes
	SampleUtilities.pretty_print_request(client, 'siem/offenses/' + str(offense_ID) + '/notes', 'GET')
	response = client.call_api('siem/offenses/' + str(offense_ID) + '/notes', 'GET')

	# Display all the notes on the offense
	SampleUtilities.pretty_print_response(response)

	# Confirm that the user wants to make a new note for the offense. We have to check this since it will
	# permanently add that note to the offense.
	confirmation = input('Would you like to make a new note for offense ' + str(offense_ID) + '? (YES/no)\n')

	if (confirmation != 'YES'):
		print('You have chosen not to post a new note. Exiting sample.')
		exit(0)

	# Take in the text for the note. Since the note could be multiple words, and the API calls through a
	# url, we are using urllib.parse.quote to preserve the spaces and special characters in the note.
	text = urllib.parse.quote(input('Please enter the content of the note.\n'))
	
	# Send in the request for the new note to be put on the offense.
	SampleUtilities.pretty_print_request(client, 'siem/offenses/' + offense_ID + '/notes?note_text=' + text, 'POST')
	response = client.call_api('siem/offenses/' + offense_ID + '/notes?note_text=' + text, 'POST')

	#Display to the user the new note to confirm that it has been created properly.
	SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client.
    client = RestApiClient(version='3.0')

    # Using the /asset_model/properties endpoint with a GET request.
    SampleUtilities.pretty_print_request(client, 'asset_model/saved_searches',
                                         'GET')
    response = client.call_api('asset_model/saved_searches', 'GET')

    # Verify that the call to the API was successful.
    if (response.code != 200):
        print('Failed to retrieve saved searches list.')
        SampleUtilities.pretty_print_response(response)
        sys.exit(1)

    # Find the number of saved searches retrieved.
    response_body = json.loads(response.read().decode('utf-8'))
    number_of_searches_retrieved = len(response_body)

    # Display number of searches, and the names of the searches retrieved.
    print(str(number_of_searches_retrieved) + ' searches were retrieved.\n')
    if (number_of_searches_retrieved > 0):
        print("Searching Assets...\n\n")
        for search in response_body:
            # Retrieve the saved search unique identifier.
            saved_search_id = str(search['id'])
            saved_search_name = str(search['name'])

            print('Running saved search : ' + saved_search_name)

            # Using the /asset_model/saved_searches/{saved_search_id}/results
            # endpoint with a GET request.
            search_endpoint_url = ('asset_model/saved_searches/' +
                                   saved_search_id + '/results')
            SampleUtilities.pretty_print_request(client, search_endpoint_url,
                                                 'GET')
            search_response = client.call_api(search_endpoint_url, 'GET')

            if(response.code != 200):
                print("Failed to search assets.")
                SampleUtilities.pretty_print_response(response)
                sys.exit(1)

            # Find the number of assets found
            search_response_body = json.loads(search_response.read().
                                              decode('utf-8'))
            number_of_assets_found = len(search_response_body)

            # Display the number of assets retrieved.
            print(str(number_of_assets_found) + ' assets were retrieved.\n')
        print()

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client and set up some sample data.
    client = RestApiClient(version="3.0")
    setup_data(client)

    # Using the '/sets/{name} endpoint with a GET request we can retrieve the
    # contents of our set of suspect addresses.
    SampleUtilities.pretty_print_request(client, "reference_data/sets/rest_api_samples_suspect_ips", "GET")
    response = client.call_api("reference_data/sets/rest_api_samples_suspect_ips", "GET")

    # Based on our business rules, this set should always exist. If it does not
    # exist it could be an indication that our security has been breached and
    # that an attack is in progress. We should raise an alarm.
    if response.code == 404:
        print("Something is wrong, a system administrator should investigate.")
        sys.exit(1)

    # Extract the reference set from the response body.
    response_body = json.loads(response.read().decode("utf-8"))
    data = response_body["data"]

    for element in data:

        # For each suspect ip address, pass it to our legacy system to
        # validate. If it is a real threat, move it to the blocked list so that
        # the configured rules can generate offenses if it is active on our
        # network.
        ip_address = element["value"]
        if legacy_system_logic(ip_address):
            SampleUtilities.pretty_print_request(
                client, "reference_data/sets/rest_api_samples_blocked_ips?value=" + ip_address, "POST"
            )
            response = client.call_api("reference_data/sets/rest_api_samples_blocked_ips?value=" + ip_address, "POST")

            SampleUtilities.pretty_print_request(
                client, "reference_data/sets/rest_api_samples_suspect_ips/" + ip_address, "DELETE"
            )
            response = client.call_api("reference_data/sets/rest_api_samples_suspect_ips/" + ip_address, "DELETE")

    # The result of this processing is that there are some ip addresses now in
    # the blocked list.
    response = client.call_api("reference_data/sets/rest_api_samples_suspect_ips", "GET")
    SampleUtilities.pretty_print_response(response)

    # The ip addresses that were not blocked are sill in the suspect list for
    # us to watch.
    response = client.call_api("reference_data/sets/rest_api_samples_blocked_ips", "GET")
    SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client.
    client = RestApiClient()

    # Using the /asset_model/assets endpoint with a GET request. 
    SampleUtilities.pretty_print_request(client, 'asset_model/assets', 'GET')
    response = client.call_api('asset_model/assets', 'GET')

    # Verify that the call to the API was successful.
    if (response.code != 200):
        print('Failed to retrieve asset list.')
        SampleUtilities.pretty_print_response(response)
        sys.exit(1)

    # Display the number of assets retrieved.
    response_body = json.loads(response.read().decode('utf-8'))
    number_of_assets_retrieved = len(response_body)
		
    # Display number of assets, and the IDs of the assets retrieved.
    print(str(number_of_assets_retrieved) + ' assets were retrieved.')
    if (number_of_assets_retrieved > 0):
        print("Asset IDs: ", end="")
        for asset in response_body:
            print(str(asset['id']) + ' ', end="")
        print()		

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client.
    client = RestApiClient()

    # Using the /asset_model/properties endpoint with a GET request. 
    SampleUtilities.pretty_print_request(client, 'asset_model/properties', 'GET')
    response = client.call_api('asset_model/properties', 'GET')

    # Verify that the call to the API was successful.
    if (response.code != 200):
        print('Failed to retrieve propertiy list.')
        SampleUtilities.pretty_print_response(response)
        sys.exit(1)

    # Display the number of properties retrieved.
    response_body = json.loads(response.read().decode('utf-8'))
    number_of_properties_retrieved = len(response_body)
		
    # Display number of properties, and the names of the properties retrieved.
    print(str(number_of_properties_retrieved) + ' properties were retrieved.')
    if (number_of_properties_retrieved > 0):
        print("Property Names: ", end="")
        for property in response_body:
            print(str(property['name']) + ', ', end="")
        print()		

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client.
    client = RestApiClient(version="3.0")

    # Using the /asset_model/assets endpoint with a GET request.
    SampleUtilities.pretty_print_request(client, "asset_model/assets", "GET")
    response = client.call_api("asset_model/assets", "GET")

    # Verify that the call to the API was successful.
    if response.code != 200:
        print("Failed to retrieve asset list.")
        SampleUtilities.pretty_print_response(response)
        sys.exit(1)

    # Display the number of assets retrieved.
    response_body = json.loads(response.read().decode("utf-8"))
    number_of_assets_retrieved = len(response_body)

    # Display number of assets, and the IDs of the assets retrieved.
    print(str(number_of_assets_retrieved) + " assets were retrieved.")
    if number_of_assets_retrieved > 0:
        print("Asset IDs: ", end="")
        for asset in response_body:
            print(str(asset["id"]) + " ", end="")
        print()

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # First we have to create our client
    client = RestApiClient(version="3.0")

    # This example gives a demonstration of how to create a new closing reason
    # for your offenses.

    # First, check what closing reasons are already available to avoid
    # creating duplicates. Send in the GET request.
    SampleUtilities.pretty_print_request(client, "siem/offense_closing_reasons", "GET")
    response = client.call_api("siem/offense_closing_reasons", "GET")
    # and output the response
    SampleUtilities.pretty_print_response(response)

    if response.code != 200:
        print("Call Failed")
        sys.exit(1)

    # Double check that the user wants to create a new closing reason
    while True:
        confirmation = input("Are you sure you want to create a new " + "closing reason? (YES/no) ")

        if confirmation == "YES":
            break
        elif confirmation == "no":
            print("Not creating a new closing reason")
            exit(0)
        else:
            print(confirmation + "is not a valid answer.")

    # Have the user input the text.
    text = input("Please enter the text you want to put in the closing reason.\n")

    # Put through the request to add a closing reason with the text the user
    # entered as the reason
    params = {"reason": text}
    response = client.call_api("siem/offense_closing_reasons", "POST", params=params, print_request=True)

    SampleUtilities.pretty_print_response(response)

    if response.code != 201:
        print("Call Failed")
        sys.exit(1)

    print("Closing reason added")

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
	# First we have to create our client
	client = RestApiClient()

	# This example gives a demonstration of how to create a new closing reason for your
	# offenses.

	# First, check what closing reasons are already available to avoid creating duplicates
	# Send in the GET request
	SampleUtilities.pretty_print_request(client, 'siem/offense_closing_reasons', 'GET')
	response = client.call_api('siem/offense_closing_reasons', 'GET')
	# and output the response
	SampleUtilities.pretty_print_response(response)

	if (response.code != 200):
		print('Call Failed')
		sys.exit(1)

	# Double check that the user wants to create a new closing reason
	while True:
		confirmation = input('Are you sure you want to create a new closing reason? (YES/no) ')

		if (confirmation == 'YES'):
			break
		elif (confirmation == 'no'):
			print('Not creating a new closing reason')
			exit(0)
		else:
			print(confirmation + 'is not a valid answer.')

	# Have the user input the text. quote it to retain special characters like spaces.
	text = urllib.parse.quote(input('Please enter the text you want to put in the closing reason.\n'))

	# Put through the request to add a closing reason with the text the user entered as the reason
	SampleUtilities.pretty_print_request(client, 'siem/offense_closing_reasons?reason=' + text, 'POST')
	response = client.call_api('siem/offense_closing_reasons?reason=' + text, 'POST')
	
	SampleUtilities.pretty_print_response(response)

	if (response.code != 201):
		print('Call Failed')
		sys.exit(1)

	print('Closing reason added')

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def main():
    # Create our client and set up some sample data.
    client = RestApiClient(version='3.0')
    setup_data(client)

    # First lets see who is on duty now.
    print("These administrators are on duty during the first shift:")
    response = client.call_api(
        'reference_data/maps/rest_api_samples_current_admin_shift', 'GET')
    SampleUtilities.pretty_print_response(response)

    # # Change to the second shift as scheduled by our HR system.

    # Get the current shift.
    response = client.call_api(
        'reference_data/maps/rest_api_samples_current_admin_shift', 'GET')
    response_body = json.loads(response.read().decode('utf-8'))
    data = response_body['data']

    # Change to the second shift.
    print("Changing to the second shift:")
    update_reference_map(get_second_shift_schedule_from_hr(), data, client)
    # Show that the change has happened.
    response = client.call_api(
        'reference_data/maps/rest_api_samples_current_admin_shift', 'GET')
    SampleUtilities.pretty_print_response(response)

    # # Change to the third shift as scheduled by our HR system.

    # Get the current shift.
    response = client.call_api(
        'reference_data/maps/rest_api_samples_current_admin_shift', 'GET')
    response_body = json.loads(response.read().decode('utf-8'))
    data = response_body['data']

    # Change to the third shift.
    print("Changing to the third shift:")
    update_reference_map(get_third_shift_schedule_from_hr(), data, client)
    # Show that the change has happened.
    response = client.call_api(
        'reference_data/maps/rest_api_samples_current_admin_shift', 'GET')
    SampleUtilities.pretty_print_response(response)

# 需要导入模块: from RestApiClient import RestApiClient [as 别名]
# 或者: from RestApiClient.RestApiClient import call_api [as 别名]
def print_api(settings):

    settings['version'] = None
    api_client = RestApiClient(settings)

    response = api_client.call_api('help/capabilities', 'GET')
    response_json = json.loads(response.read().decode('utf-8'))

    for category in response_json['categories']:
        for api in category['apis']:
            print("API: " + category['path'] + api['path'])
            print("Operations:")

            for operation in api['operations']:
                print("\tVersion: " + str(operation['version']))
                print("\tMethod: " + operation['httpMethod'])

                desc = re.sub("[\\t\\n\\r]+"," ", operation['description'])

                print("\tDescription: " + desc)

                sys.stdout.write("\tOutput Type(s): ")
                response_types = []
                for response_type in operation['supportedContentTypes']:
                    response_types.append(response_type['mimeType'])
                print(", ".join(response_types))
                print("\tParameters: ")

                for params in operation['parameters']:

                    print("\t\tName: " + params['name'])
                    if params['description']:
                        desc = re.sub("[\\t\\n\\r]+"," ", params['description'])
                        print("\t\tDescription: " + desc)

                    print ("\t\tSource: " + params['source'])

                    print("\t\tRequired: " + str(params['required']))

                    for contentTypes in params['supportedContentTypes']:
                        try:
                            if contentTypes['dataType']:
                                print("\t\tType: " + contentTypes['dataType'])
                        except KeyError:
                            print("\t\tType: " + params['dataType'])
                        print("\t\tMimeType: " + contentTypes['mimeType'])
                        print("")