nist-csf-2-mcp-server

POST Analyze maturity trends over a given time period

{{baseUrl}}/api/tools/calculate_maturity_trend

BODY json

{
  "profile_id": "",
  "time_period_months": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/calculate_maturity_trend");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/calculate_maturity_trend" {:content-type :json
                                                                               :form-params {:profile_id ""
                                                                                             :time_period_months 0}})

require "http/client"

url = "{{baseUrl}}/api/tools/calculate_maturity_trend"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/calculate_maturity_trend"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/calculate_maturity_trend");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/calculate_maturity_trend"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/calculate_maturity_trend HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "profile_id": "",
  "time_period_months": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/calculate_maturity_trend")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/calculate_maturity_trend"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/calculate_maturity_trend")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/calculate_maturity_trend")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  time_period_months: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/calculate_maturity_trend');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_maturity_trend',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', time_period_months: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/calculate_maturity_trend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","time_period_months":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/calculate_maturity_trend',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "time_period_months": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/calculate_maturity_trend")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/calculate_maturity_trend',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', time_period_months: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_maturity_trend',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', time_period_months: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/calculate_maturity_trend');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  time_period_months: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_maturity_trend',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', time_period_months: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/calculate_maturity_trend';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","time_period_months":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"time_period_months": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/calculate_maturity_trend"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/calculate_maturity_trend" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/calculate_maturity_trend",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'time_period_months' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/calculate_maturity_trend', [
  'body' => '{
  "profile_id": "",
  "time_period_months": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/calculate_maturity_trend');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'time_period_months' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'time_period_months' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/calculate_maturity_trend');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/calculate_maturity_trend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "time_period_months": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/calculate_maturity_trend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "time_period_months": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/calculate_maturity_trend", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/calculate_maturity_trend"

payload = {
    "profile_id": "",
    "time_period_months": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/calculate_maturity_trend"

payload <- "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/calculate_maturity_trend")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/calculate_maturity_trend') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"time_period_months\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/calculate_maturity_trend";

    let payload = json!({
        "profile_id": "",
        "time_period_months": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/calculate_maturity_trend \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "time_period_months": 0
}'

echo '{
  "profile_id": "",
  "time_period_months": 0
}' |  \
  http POST {{baseUrl}}/api/tools/calculate_maturity_trend \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "time_period_months": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/calculate_maturity_trend

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "time_period_months": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/calculate_maturity_trend")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Calculate organizational cybersecurity risk score

{{baseUrl}}/api/tools/calculate_risk_score

BODY json

{
  "profile_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/calculate_risk_score");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/calculate_risk_score" {:content-type :json
                                                                           :form-params {:profile_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/calculate_risk_score"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/calculate_risk_score"),
    Content = new StringContent("{\n  \"profile_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/calculate_risk_score");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/calculate_risk_score"

	payload := strings.NewReader("{\n  \"profile_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/calculate_risk_score HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "profile_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/calculate_risk_score")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/calculate_risk_score"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/calculate_risk_score")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/calculate_risk_score")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/calculate_risk_score');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_risk_score',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/calculate_risk_score';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/calculate_risk_score',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/calculate_risk_score")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/calculate_risk_score',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_risk_score',
  headers: {'content-type': 'application/json'},
  body: {profile_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/calculate_risk_score');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/calculate_risk_score',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/calculate_risk_score';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/calculate_risk_score"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/calculate_risk_score" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/calculate_risk_score",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/calculate_risk_score', [
  'body' => '{
  "profile_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/calculate_risk_score');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/calculate_risk_score');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/calculate_risk_score' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/calculate_risk_score' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/calculate_risk_score", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/calculate_risk_score"

payload = { "profile_id": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/calculate_risk_score"

payload <- "{\n  \"profile_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/calculate_risk_score")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/calculate_risk_score') do |req|
  req.body = "{\n  \"profile_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/calculate_risk_score";

    let payload = json!({"profile_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/calculate_risk_score \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": ""
}'

echo '{
  "profile_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/calculate_risk_score \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/calculate_risk_score

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["profile_id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/calculate_risk_score")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Check MCP server health

{{baseUrl}}/health

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/health");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/health")

require "http/client"

url = "{{baseUrl}}/health"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/health"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/health"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/health HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/health")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/health"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/health")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/health")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/health');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/health',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/health")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/health',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/health'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/health');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/health"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/health" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/health",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/health');

echo $response->getBody();

setUrl('{{baseUrl}}/health');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/health' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/health' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/health")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/health"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/health"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/health') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/health";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/health

http GET {{baseUrl}}/health

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/health

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/health")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Check status of an existing assessment workflow

{{baseUrl}}/api/tools/check_assessment_workflow_status

BODY json

{
  "workflow_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/check_assessment_workflow_status");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"workflow_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/check_assessment_workflow_status" {:content-type :json
                                                                                       :form-params {:workflow_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/check_assessment_workflow_status"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"workflow_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/check_assessment_workflow_status"),
    Content = new StringContent("{\n  \"workflow_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/check_assessment_workflow_status");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"workflow_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/check_assessment_workflow_status"

	payload := strings.NewReader("{\n  \"workflow_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/check_assessment_workflow_status HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "workflow_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/check_assessment_workflow_status")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"workflow_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/check_assessment_workflow_status"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"workflow_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"workflow_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/check_assessment_workflow_status")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/check_assessment_workflow_status")
  .header("content-type", "application/json")
  .body("{\n  \"workflow_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  workflow_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/check_assessment_workflow_status');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/check_assessment_workflow_status',
  headers: {'content-type': 'application/json'},
  data: {workflow_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/check_assessment_workflow_status';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workflow_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/check_assessment_workflow_status',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "workflow_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"workflow_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/check_assessment_workflow_status")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/check_assessment_workflow_status',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({workflow_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/check_assessment_workflow_status',
  headers: {'content-type': 'application/json'},
  body: {workflow_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/check_assessment_workflow_status');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  workflow_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/check_assessment_workflow_status',
  headers: {'content-type': 'application/json'},
  data: {workflow_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/check_assessment_workflow_status';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workflow_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"workflow_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/check_assessment_workflow_status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/check_assessment_workflow_status" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"workflow_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/check_assessment_workflow_status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'workflow_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/check_assessment_workflow_status', [
  'body' => '{
  "workflow_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/check_assessment_workflow_status');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'workflow_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'workflow_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/check_assessment_workflow_status');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/check_assessment_workflow_status' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workflow_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/check_assessment_workflow_status' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workflow_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"workflow_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/check_assessment_workflow_status", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/check_assessment_workflow_status"

payload = { "workflow_id": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/check_assessment_workflow_status"

payload <- "{\n  \"workflow_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/check_assessment_workflow_status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"workflow_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/check_assessment_workflow_status') do |req|
  req.body = "{\n  \"workflow_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/check_assessment_workflow_status";

    let payload = json!({"workflow_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/check_assessment_workflow_status \
  --header 'content-type: application/json' \
  --data '{
  "workflow_id": ""
}'

echo '{
  "workflow_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/check_assessment_workflow_status \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "workflow_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/check_assessment_workflow_status

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["workflow_id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/check_assessment_workflow_status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Compare two organization profiles

{{baseUrl}}/api/tools/compare_profiles

BODY json

{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/compare_profiles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/compare_profiles" {:content-type :json
                                                                       :form-params {:profile1_id ""
                                                                                     :profile2_id ""
                                                                                     :comparison_type ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/compare_profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/compare_profiles"),
    Content = new StringContent("{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/compare_profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/compare_profiles"

	payload := strings.NewReader("{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/compare_profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/compare_profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/compare_profiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/compare_profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/compare_profiles")
  .header("content-type", "application/json")
  .body("{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile1_id: '',
  profile2_id: '',
  comparison_type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/compare_profiles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/compare_profiles',
  headers: {'content-type': 'application/json'},
  data: {profile1_id: '', profile2_id: '', comparison_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/compare_profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile1_id":"","profile2_id":"","comparison_type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/compare_profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile1_id": "",\n  "profile2_id": "",\n  "comparison_type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/compare_profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/compare_profiles',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile1_id: '', profile2_id: '', comparison_type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/compare_profiles',
  headers: {'content-type': 'application/json'},
  body: {profile1_id: '', profile2_id: '', comparison_type: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/compare_profiles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile1_id: '',
  profile2_id: '',
  comparison_type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/compare_profiles',
  headers: {'content-type': 'application/json'},
  data: {profile1_id: '', profile2_id: '', comparison_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/compare_profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile1_id":"","profile2_id":"","comparison_type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile1_id": @"",
                              @"profile2_id": @"",
                              @"comparison_type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/compare_profiles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/compare_profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/compare_profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile1_id' => '',
    'profile2_id' => '',
    'comparison_type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/compare_profiles', [
  'body' => '{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/compare_profiles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile1_id' => '',
  'profile2_id' => '',
  'comparison_type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile1_id' => '',
  'profile2_id' => '',
  'comparison_type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/compare_profiles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/compare_profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/compare_profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/compare_profiles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/compare_profiles"

payload = {
    "profile1_id": "",
    "profile2_id": "",
    "comparison_type": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/compare_profiles"

payload <- "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/compare_profiles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/compare_profiles') do |req|
  req.body = "{\n  \"profile1_id\": \"\",\n  \"profile2_id\": \"\",\n  \"comparison_type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/compare_profiles";

    let payload = json!({
        "profile1_id": "",
        "profile2_id": "",
        "comparison_type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/compare_profiles \
  --header 'content-type: application/json' \
  --data '{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}'

echo '{
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
}' |  \
  http POST {{baseUrl}}/api/tools/compare_profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile1_id": "",\n  "profile2_id": "",\n  "comparison_type": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/compare_profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile1_id": "",
  "profile2_id": "",
  "comparison_type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/compare_profiles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Conduct a quick interactive cybersecurity assessment

{{baseUrl}}/api/tools/quick_assessment

BODY json

{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/quick_assessment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/quick_assessment" {:content-type :json
                                                                       :form-params {:profile_id ""
                                                                                     :simplified_answers {}
                                                                                     :assessed_by ""
                                                                                     :confidence_level ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/quick_assessment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/quick_assessment"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/quick_assessment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/quick_assessment"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/quick_assessment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 97

{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/quick_assessment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/quick_assessment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/quick_assessment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/quick_assessment")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  simplified_answers: {},
  assessed_by: '',
  confidence_level: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/quick_assessment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/quick_assessment',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', simplified_answers: {}, assessed_by: '', confidence_level: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/quick_assessment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","simplified_answers":{},"assessed_by":"","confidence_level":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/quick_assessment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "simplified_answers": {},\n  "assessed_by": "",\n  "confidence_level": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/quick_assessment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/quick_assessment',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', simplified_answers: {}, assessed_by: '', confidence_level: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/quick_assessment',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', simplified_answers: {}, assessed_by: '', confidence_level: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/quick_assessment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  simplified_answers: {},
  assessed_by: '',
  confidence_level: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/quick_assessment',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', simplified_answers: {}, assessed_by: '', confidence_level: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/quick_assessment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","simplified_answers":{},"assessed_by":"","confidence_level":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"simplified_answers": @{  },
                              @"assessed_by": @"",
                              @"confidence_level": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/quick_assessment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/quick_assessment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/quick_assessment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'simplified_answers' => [
        
    ],
    'assessed_by' => '',
    'confidence_level' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/quick_assessment', [
  'body' => '{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/quick_assessment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'simplified_answers' => [
    
  ],
  'assessed_by' => '',
  'confidence_level' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'simplified_answers' => [
    
  ],
  'assessed_by' => '',
  'confidence_level' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/quick_assessment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/quick_assessment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/quick_assessment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/quick_assessment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/quick_assessment"

payload = {
    "profile_id": "",
    "simplified_answers": {},
    "assessed_by": "",
    "confidence_level": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/quick_assessment"

payload <- "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/quick_assessment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/quick_assessment') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"simplified_answers\": {},\n  \"assessed_by\": \"\",\n  \"confidence_level\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/quick_assessment";

    let payload = json!({
        "profile_id": "",
        "simplified_answers": json!({}),
        "assessed_by": "",
        "confidence_level": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/quick_assessment \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}'

echo '{
  "profile_id": "",
  "simplified_answers": {},
  "assessed_by": "",
  "confidence_level": ""
}' |  \
  http POST {{baseUrl}}/api/tools/quick_assessment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "simplified_answers": {},\n  "assessed_by": "",\n  "confidence_level": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/quick_assessment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "simplified_answers": [],
  "assessed_by": "",
  "confidence_level": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/quick_assessment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a new organization profile

{{baseUrl}}/api/tools/create_profile

BODY json

{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/create_profile");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/create_profile" {:content-type :json
                                                                     :form-params {:org_name ""
                                                                                   :industry ""
                                                                                   :size ""
                                                                                   :current_tier ""
                                                                                   :target_tier ""
                                                                                   :description ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/create_profile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/create_profile"),
    Content = new StringContent("{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/create_profile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/create_profile"

	payload := strings.NewReader("{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/create_profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/create_profile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/create_profile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/create_profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/create_profile")
  .header("content-type", "application/json")
  .body("{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  org_name: '',
  industry: '',
  size: '',
  current_tier: '',
  target_tier: '',
  description: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/create_profile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_profile',
  headers: {'content-type': 'application/json'},
  data: {
    org_name: '',
    industry: '',
    size: '',
    current_tier: '',
    target_tier: '',
    description: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/create_profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"org_name":"","industry":"","size":"","current_tier":"","target_tier":"","description":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/create_profile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "org_name": "",\n  "industry": "",\n  "size": "",\n  "current_tier": "",\n  "target_tier": "",\n  "description": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/create_profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/create_profile',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  org_name: '',
  industry: '',
  size: '',
  current_tier: '',
  target_tier: '',
  description: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_profile',
  headers: {'content-type': 'application/json'},
  body: {
    org_name: '',
    industry: '',
    size: '',
    current_tier: '',
    target_tier: '',
    description: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/create_profile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  org_name: '',
  industry: '',
  size: '',
  current_tier: '',
  target_tier: '',
  description: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_profile',
  headers: {'content-type': 'application/json'},
  data: {
    org_name: '',
    industry: '',
    size: '',
    current_tier: '',
    target_tier: '',
    description: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/create_profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"org_name":"","industry":"","size":"","current_tier":"","target_tier":"","description":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"org_name": @"",
                              @"industry": @"",
                              @"size": @"",
                              @"current_tier": @"",
                              @"target_tier": @"",
                              @"description": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/create_profile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/create_profile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/create_profile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'org_name' => '',
    'industry' => '',
    'size' => '',
    'current_tier' => '',
    'target_tier' => '',
    'description' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/create_profile', [
  'body' => '{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/create_profile');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'org_name' => '',
  'industry' => '',
  'size' => '',
  'current_tier' => '',
  'target_tier' => '',
  'description' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'org_name' => '',
  'industry' => '',
  'size' => '',
  'current_tier' => '',
  'target_tier' => '',
  'description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/create_profile');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/create_profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/create_profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/create_profile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/create_profile"

payload = {
    "org_name": "",
    "industry": "",
    "size": "",
    "current_tier": "",
    "target_tier": "",
    "description": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/create_profile"

payload <- "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/create_profile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/create_profile') do |req|
  req.body = "{\n  \"org_name\": \"\",\n  \"industry\": \"\",\n  \"size\": \"\",\n  \"current_tier\": \"\",\n  \"target_tier\": \"\",\n  \"description\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/create_profile";

    let payload = json!({
        "org_name": "",
        "industry": "",
        "size": "",
        "current_tier": "",
        "target_tier": "",
        "description": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/create_profile \
  --header 'content-type: application/json' \
  --data '{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}'

echo '{
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
}' |  \
  http POST {{baseUrl}}/api/tools/create_profile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "org_name": "",\n  "industry": "",\n  "size": "",\n  "current_tier": "",\n  "target_tier": "",\n  "description": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/create_profile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "org_name": "",
  "industry": "",
  "size": "",
  "current_tier": "",
  "target_tier": "",
  "description": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/create_profile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Estimate implementation costs for a profile

{{baseUrl}}/api/tools/estimate_implementation_cost

BODY json

{
  "profile_id": "",
  "cost_model": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/estimate_implementation_cost");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/estimate_implementation_cost" {:content-type :json
                                                                                   :form-params {:profile_id ""
                                                                                                 :cost_model ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/estimate_implementation_cost"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/estimate_implementation_cost"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/estimate_implementation_cost");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/estimate_implementation_cost"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/estimate_implementation_cost HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "profile_id": "",
  "cost_model": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/estimate_implementation_cost")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/estimate_implementation_cost"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/estimate_implementation_cost")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/estimate_implementation_cost")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  cost_model: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/estimate_implementation_cost');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/estimate_implementation_cost',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', cost_model: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/estimate_implementation_cost';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","cost_model":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/estimate_implementation_cost',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "cost_model": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/estimate_implementation_cost")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/estimate_implementation_cost',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', cost_model: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/estimate_implementation_cost',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', cost_model: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/estimate_implementation_cost');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  cost_model: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/estimate_implementation_cost',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', cost_model: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/estimate_implementation_cost';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","cost_model":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"cost_model": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/estimate_implementation_cost"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/estimate_implementation_cost" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/estimate_implementation_cost",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'cost_model' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/estimate_implementation_cost', [
  'body' => '{
  "profile_id": "",
  "cost_model": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/estimate_implementation_cost');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'cost_model' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'cost_model' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/estimate_implementation_cost');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/estimate_implementation_cost' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "cost_model": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/estimate_implementation_cost' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "cost_model": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/estimate_implementation_cost", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/estimate_implementation_cost"

payload = {
    "profile_id": "",
    "cost_model": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/estimate_implementation_cost"

payload <- "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/estimate_implementation_cost")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/estimate_implementation_cost') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"cost_model\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/estimate_implementation_cost";

    let payload = json!({
        "profile_id": "",
        "cost_model": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/estimate_implementation_cost \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "cost_model": ""
}'

echo '{
  "profile_id": "",
  "cost_model": ""
}' |  \
  http POST {{baseUrl}}/api/tools/estimate_implementation_cost \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "cost_model": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/estimate_implementation_cost

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "cost_model": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/estimate_implementation_cost")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Export assessment data for a profile

{{baseUrl}}/api/tools/export_data

BODY json

{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/export_data");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/export_data" {:content-type :json
                                                                  :form-params {:profile_id ""
                                                                                :export_format ""
                                                                                :include_metadata false}})

require "http/client"

url = "{{baseUrl}}/api/tools/export_data"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/export_data"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/export_data");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/export_data"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/export_data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/export_data")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/export_data"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/export_data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/export_data")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  export_format: '',
  include_metadata: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/export_data');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/export_data',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', export_format: '', include_metadata: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/export_data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","export_format":"","include_metadata":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/export_data',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "export_format": "",\n  "include_metadata": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/export_data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/export_data',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', export_format: '', include_metadata: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/export_data',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', export_format: '', include_metadata: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/export_data');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  export_format: '',
  include_metadata: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/export_data',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', export_format: '', include_metadata: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/export_data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","export_format":"","include_metadata":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"export_format": @"",
                              @"include_metadata": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/export_data"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/export_data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/export_data",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'export_format' => '',
    'include_metadata' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/export_data', [
  'body' => '{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/export_data');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'export_format' => '',
  'include_metadata' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'export_format' => '',
  'include_metadata' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/export_data');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/export_data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/export_data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/export_data", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/export_data"

payload = {
    "profile_id": "",
    "export_format": "",
    "include_metadata": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/export_data"

payload <- "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/export_data")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/export_data') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"export_format\": \"\",\n  \"include_metadata\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/export_data";

    let payload = json!({
        "profile_id": "",
        "export_format": "",
        "include_metadata": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/export_data \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}'

echo '{
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
}' |  \
  http POST {{baseUrl}}/api/tools/export_data \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "export_format": "",\n  "include_metadata": false\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/export_data

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "export_format": "",
  "include_metadata": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/export_data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate a comprehensive report for a profile

{{baseUrl}}/api/tools/generate_report

BODY json

{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/generate_report");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/generate_report" {:content-type :json
                                                                      :form-params {:profile_id ""
                                                                                    :report_type ""
                                                                                    :include_recommendations false
                                                                                    :include_charts false}})

require "http/client"

url = "{{baseUrl}}/api/tools/generate_report"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/generate_report"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/generate_report");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/generate_report"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/generate_report HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/generate_report")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/generate_report"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_report")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/generate_report")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  report_type: '',
  include_recommendations: false,
  include_charts: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/generate_report');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_report',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    report_type: '',
    include_recommendations: false,
    include_charts: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/generate_report';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","report_type":"","include_recommendations":false,"include_charts":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/generate_report',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "report_type": "",\n  "include_recommendations": false,\n  "include_charts": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_report")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/generate_report',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  profile_id: '',
  report_type: '',
  include_recommendations: false,
  include_charts: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_report',
  headers: {'content-type': 'application/json'},
  body: {
    profile_id: '',
    report_type: '',
    include_recommendations: false,
    include_charts: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/generate_report');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  report_type: '',
  include_recommendations: false,
  include_charts: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_report',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    report_type: '',
    include_recommendations: false,
    include_charts: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/generate_report';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","report_type":"","include_recommendations":false,"include_charts":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"report_type": @"",
                              @"include_recommendations": @NO,
                              @"include_charts": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/generate_report"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/generate_report" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/generate_report",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'report_type' => '',
    'include_recommendations' => null,
    'include_charts' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/generate_report', [
  'body' => '{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/generate_report');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'report_type' => '',
  'include_recommendations' => null,
  'include_charts' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'report_type' => '',
  'include_recommendations' => null,
  'include_charts' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/generate_report');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/generate_report' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/generate_report' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/generate_report", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/generate_report"

payload = {
    "profile_id": "",
    "report_type": "",
    "include_recommendations": False,
    "include_charts": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/generate_report"

payload <- "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/generate_report")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/generate_report') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"report_type\": \"\",\n  \"include_recommendations\": false,\n  \"include_charts\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/generate_report";

    let payload = json!({
        "profile_id": "",
        "report_type": "",
        "include_recommendations": false,
        "include_charts": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/generate_report \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}'

echo '{
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
}' |  \
  http POST {{baseUrl}}/api/tools/generate_report \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "report_type": "",\n  "include_recommendations": false,\n  "include_charts": false\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/generate_report

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "report_type": "",
  "include_recommendations": false,
  "include_charts": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/generate_report")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate a detailed implementation roadmap

{{baseUrl}}/api/tools/create_implementation_plan

BODY json

{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/create_implementation_plan");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/create_implementation_plan" {:content-type :json
                                                                                 :form-params {:profile_id ""
                                                                                               :planning_horizon_months 0
                                                                                               :resource_constraints {:budget ""
                                                                                                                      :staff_hours_per_month 0}
                                                                                               :priority_focus ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/create_implementation_plan"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/create_implementation_plan"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/create_implementation_plan");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/create_implementation_plan"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/create_implementation_plan HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 160

{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/create_implementation_plan")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/create_implementation_plan"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/create_implementation_plan")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/create_implementation_plan")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  planning_horizon_months: 0,
  resource_constraints: {
    budget: '',
    staff_hours_per_month: 0
  },
  priority_focus: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/create_implementation_plan');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_implementation_plan',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    planning_horizon_months: 0,
    resource_constraints: {budget: '', staff_hours_per_month: 0},
    priority_focus: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/create_implementation_plan';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","planning_horizon_months":0,"resource_constraints":{"budget":"","staff_hours_per_month":0},"priority_focus":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/create_implementation_plan',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "planning_horizon_months": 0,\n  "resource_constraints": {\n    "budget": "",\n    "staff_hours_per_month": 0\n  },\n  "priority_focus": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/create_implementation_plan")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/create_implementation_plan',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  profile_id: '',
  planning_horizon_months: 0,
  resource_constraints: {budget: '', staff_hours_per_month: 0},
  priority_focus: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_implementation_plan',
  headers: {'content-type': 'application/json'},
  body: {
    profile_id: '',
    planning_horizon_months: 0,
    resource_constraints: {budget: '', staff_hours_per_month: 0},
    priority_focus: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/create_implementation_plan');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  planning_horizon_months: 0,
  resource_constraints: {
    budget: '',
    staff_hours_per_month: 0
  },
  priority_focus: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/create_implementation_plan',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    planning_horizon_months: 0,
    resource_constraints: {budget: '', staff_hours_per_month: 0},
    priority_focus: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/create_implementation_plan';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","planning_horizon_months":0,"resource_constraints":{"budget":"","staff_hours_per_month":0},"priority_focus":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"planning_horizon_months": @0,
                              @"resource_constraints": @{ @"budget": @"", @"staff_hours_per_month": @0 },
                              @"priority_focus": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/create_implementation_plan"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/create_implementation_plan" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/create_implementation_plan",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'planning_horizon_months' => 0,
    'resource_constraints' => [
        'budget' => '',
        'staff_hours_per_month' => 0
    ],
    'priority_focus' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/create_implementation_plan', [
  'body' => '{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/create_implementation_plan');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'planning_horizon_months' => 0,
  'resource_constraints' => [
    'budget' => '',
    'staff_hours_per_month' => 0
  ],
  'priority_focus' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'planning_horizon_months' => 0,
  'resource_constraints' => [
    'budget' => '',
    'staff_hours_per_month' => 0
  ],
  'priority_focus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/create_implementation_plan');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/create_implementation_plan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/create_implementation_plan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/create_implementation_plan", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/create_implementation_plan"

payload = {
    "profile_id": "",
    "planning_horizon_months": 0,
    "resource_constraints": {
        "budget": "",
        "staff_hours_per_month": 0
    },
    "priority_focus": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/create_implementation_plan"

payload <- "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/create_implementation_plan")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/create_implementation_plan') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"planning_horizon_months\": 0,\n  \"resource_constraints\": {\n    \"budget\": \"\",\n    \"staff_hours_per_month\": 0\n  },\n  \"priority_focus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/create_implementation_plan";

    let payload = json!({
        "profile_id": "",
        "planning_horizon_months": 0,
        "resource_constraints": json!({
            "budget": "",
            "staff_hours_per_month": 0
        }),
        "priority_focus": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/create_implementation_plan \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}'

echo '{
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": {
    "budget": "",
    "staff_hours_per_month": 0
  },
  "priority_focus": ""
}' |  \
  http POST {{baseUrl}}/api/tools/create_implementation_plan \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "planning_horizon_months": 0,\n  "resource_constraints": {\n    "budget": "",\n    "staff_hours_per_month": 0\n  },\n  "priority_focus": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/create_implementation_plan

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "planning_horizon_months": 0,
  "resource_constraints": [
    "budget": "",
    "staff_hours_per_month": 0
  ],
  "priority_focus": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/create_implementation_plan")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate a gap analysis report for a profile

{{baseUrl}}/api/tools/generate_gap_analysis

BODY json

{
  "profile_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/generate_gap_analysis");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/generate_gap_analysis" {:content-type :json
                                                                            :form-params {:profile_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/generate_gap_analysis"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/generate_gap_analysis"),
    Content = new StringContent("{\n  \"profile_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/generate_gap_analysis");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/generate_gap_analysis"

	payload := strings.NewReader("{\n  \"profile_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/generate_gap_analysis HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "profile_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/generate_gap_analysis")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/generate_gap_analysis"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_gap_analysis")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/generate_gap_analysis")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/generate_gap_analysis');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_gap_analysis',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/generate_gap_analysis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/generate_gap_analysis',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_gap_analysis")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/generate_gap_analysis',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_gap_analysis',
  headers: {'content-type': 'application/json'},
  body: {profile_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/generate_gap_analysis');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_gap_analysis',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/generate_gap_analysis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/generate_gap_analysis"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/generate_gap_analysis" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/generate_gap_analysis",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/generate_gap_analysis', [
  'body' => '{
  "profile_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/generate_gap_analysis');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/generate_gap_analysis');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/generate_gap_analysis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/generate_gap_analysis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/generate_gap_analysis", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/generate_gap_analysis"

payload = { "profile_id": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/generate_gap_analysis"

payload <- "{\n  \"profile_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/generate_gap_analysis")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/generate_gap_analysis') do |req|
  req.body = "{\n  \"profile_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/generate_gap_analysis";

    let payload = json!({"profile_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/generate_gap_analysis \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": ""
}'

echo '{
  "profile_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/generate_gap_analysis \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/generate_gap_analysis

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["profile_id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/generate_gap_analysis")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate an implementation priority matrix

{{baseUrl}}/api/tools/generate_priority_matrix

BODY json

{
  "profile_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/generate_priority_matrix");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/generate_priority_matrix" {:content-type :json
                                                                               :form-params {:profile_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/generate_priority_matrix"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/generate_priority_matrix"),
    Content = new StringContent("{\n  \"profile_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/generate_priority_matrix");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/generate_priority_matrix"

	payload := strings.NewReader("{\n  \"profile_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/generate_priority_matrix HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "profile_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/generate_priority_matrix")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/generate_priority_matrix"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_priority_matrix")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/generate_priority_matrix")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/generate_priority_matrix');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_priority_matrix',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/generate_priority_matrix';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/generate_priority_matrix',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_priority_matrix")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/generate_priority_matrix',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_priority_matrix',
  headers: {'content-type': 'application/json'},
  body: {profile_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/generate_priority_matrix');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_priority_matrix',
  headers: {'content-type': 'application/json'},
  data: {profile_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/generate_priority_matrix';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/generate_priority_matrix"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/generate_priority_matrix" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/generate_priority_matrix",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/generate_priority_matrix', [
  'body' => '{
  "profile_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/generate_priority_matrix');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/generate_priority_matrix');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/generate_priority_matrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/generate_priority_matrix' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/generate_priority_matrix", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/generate_priority_matrix"

payload = { "profile_id": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/generate_priority_matrix"

payload <- "{\n  \"profile_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/generate_priority_matrix")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/generate_priority_matrix') do |req|
  req.body = "{\n  \"profile_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/generate_priority_matrix";

    let payload = json!({"profile_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/generate_priority_matrix \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": ""
}'

echo '{
  "profile_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/generate_priority_matrix \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/generate_priority_matrix

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["profile_id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/generate_priority_matrix")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate policy template for a subcategory

{{baseUrl}}/api/tools/generate_policy_template

BODY json

{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/generate_policy_template");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/generate_policy_template" {:content-type :json
                                                                               :form-params {:subcategory_id ""
                                                                                             :industry ""
                                                                                             :organization_size ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/generate_policy_template"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/generate_policy_template"),
    Content = new StringContent("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/generate_policy_template");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/generate_policy_template"

	payload := strings.NewReader("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/generate_policy_template HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/generate_policy_template")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/generate_policy_template"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_policy_template")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/generate_policy_template")
  .header("content-type", "application/json")
  .body("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  subcategory_id: '',
  industry: '',
  organization_size: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/generate_policy_template');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_policy_template',
  headers: {'content-type': 'application/json'},
  data: {subcategory_id: '', industry: '', organization_size: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/generate_policy_template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","industry":"","organization_size":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/generate_policy_template',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "subcategory_id": "",\n  "industry": "",\n  "organization_size": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_policy_template")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/generate_policy_template',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({subcategory_id: '', industry: '', organization_size: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_policy_template',
  headers: {'content-type': 'application/json'},
  body: {subcategory_id: '', industry: '', organization_size: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/generate_policy_template');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  subcategory_id: '',
  industry: '',
  organization_size: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_policy_template',
  headers: {'content-type': 'application/json'},
  data: {subcategory_id: '', industry: '', organization_size: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/generate_policy_template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","industry":"","organization_size":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"subcategory_id": @"",
                              @"industry": @"",
                              @"organization_size": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/generate_policy_template"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/generate_policy_template" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/generate_policy_template",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'subcategory_id' => '',
    'industry' => '',
    'organization_size' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/generate_policy_template', [
  'body' => '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/generate_policy_template');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'subcategory_id' => '',
  'industry' => '',
  'organization_size' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'subcategory_id' => '',
  'industry' => '',
  'organization_size' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/generate_policy_template');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/generate_policy_template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/generate_policy_template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/generate_policy_template", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/generate_policy_template"

payload = {
    "subcategory_id": "",
    "industry": "",
    "organization_size": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/generate_policy_template"

payload <- "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/generate_policy_template")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/generate_policy_template') do |req|
  req.body = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/generate_policy_template";

    let payload = json!({
        "subcategory_id": "",
        "industry": "",
        "organization_size": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/generate_policy_template \
  --header 'content-type: application/json' \
  --data '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}'

echo '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
}' |  \
  http POST {{baseUrl}}/api/tools/generate_policy_template \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "subcategory_id": "",\n  "industry": "",\n  "organization_size": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/generate_policy_template

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "subcategory_id": "",
  "industry": "",
  "organization_size": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/generate_policy_template")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Generate security test scenarios for a subcategory

{{baseUrl}}/api/tools/generate_test_scenarios

BODY json

{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/generate_test_scenarios");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/generate_test_scenarios" {:content-type :json
                                                                              :form-params {:subcategory_id ""
                                                                                            :test_type ""
                                                                                            :include_scripts false
                                                                                            :include_tools false
                                                                                            :severity_levels []}})

require "http/client"

url = "{{baseUrl}}/api/tools/generate_test_scenarios"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/generate_test_scenarios"),
    Content = new StringContent("{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/generate_test_scenarios");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/generate_test_scenarios"

	payload := strings.NewReader("{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/generate_test_scenarios HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/generate_test_scenarios")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/generate_test_scenarios"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_test_scenarios")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/generate_test_scenarios")
  .header("content-type", "application/json")
  .body("{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}")
  .asString();

const data = JSON.stringify({
  subcategory_id: '',
  test_type: '',
  include_scripts: false,
  include_tools: false,
  severity_levels: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/generate_test_scenarios');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_test_scenarios',
  headers: {'content-type': 'application/json'},
  data: {
    subcategory_id: '',
    test_type: '',
    include_scripts: false,
    include_tools: false,
    severity_levels: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/generate_test_scenarios';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","test_type":"","include_scripts":false,"include_tools":false,"severity_levels":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/generate_test_scenarios',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "subcategory_id": "",\n  "test_type": "",\n  "include_scripts": false,\n  "include_tools": false,\n  "severity_levels": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/generate_test_scenarios")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/generate_test_scenarios',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  subcategory_id: '',
  test_type: '',
  include_scripts: false,
  include_tools: false,
  severity_levels: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_test_scenarios',
  headers: {'content-type': 'application/json'},
  body: {
    subcategory_id: '',
    test_type: '',
    include_scripts: false,
    include_tools: false,
    severity_levels: []
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/generate_test_scenarios');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  subcategory_id: '',
  test_type: '',
  include_scripts: false,
  include_tools: false,
  severity_levels: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/generate_test_scenarios',
  headers: {'content-type': 'application/json'},
  data: {
    subcategory_id: '',
    test_type: '',
    include_scripts: false,
    include_tools: false,
    severity_levels: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/generate_test_scenarios';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","test_type":"","include_scripts":false,"include_tools":false,"severity_levels":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"subcategory_id": @"",
                              @"test_type": @"",
                              @"include_scripts": @NO,
                              @"include_tools": @NO,
                              @"severity_levels": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/generate_test_scenarios"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/generate_test_scenarios" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/generate_test_scenarios",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'subcategory_id' => '',
    'test_type' => '',
    'include_scripts' => null,
    'include_tools' => null,
    'severity_levels' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/generate_test_scenarios', [
  'body' => '{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/generate_test_scenarios');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'subcategory_id' => '',
  'test_type' => '',
  'include_scripts' => null,
  'include_tools' => null,
  'severity_levels' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'subcategory_id' => '',
  'test_type' => '',
  'include_scripts' => null,
  'include_tools' => null,
  'severity_levels' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/generate_test_scenarios');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/generate_test_scenarios' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/generate_test_scenarios' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/generate_test_scenarios", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/generate_test_scenarios"

payload = {
    "subcategory_id": "",
    "test_type": "",
    "include_scripts": False,
    "include_tools": False,
    "severity_levels": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/generate_test_scenarios"

payload <- "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/generate_test_scenarios")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/generate_test_scenarios') do |req|
  req.body = "{\n  \"subcategory_id\": \"\",\n  \"test_type\": \"\",\n  \"include_scripts\": false,\n  \"include_tools\": false,\n  \"severity_levels\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/generate_test_scenarios";

    let payload = json!({
        "subcategory_id": "",
        "test_type": "",
        "include_scripts": false,
        "include_tools": false,
        "severity_levels": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/generate_test_scenarios \
  --header 'content-type: application/json' \
  --data '{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}'

echo '{
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
}' |  \
  http POST {{baseUrl}}/api/tools/generate_test_scenarios \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "subcategory_id": "",\n  "test_type": "",\n  "include_scripts": false,\n  "include_tools": false,\n  "severity_levels": []\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/generate_test_scenarios

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "subcategory_id": "",
  "test_type": "",
  "include_scripts": false,
  "include_tools": false,
  "severity_levels": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/generate_test_scenarios")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Get AI-powered recommended next actions

{{baseUrl}}/api/tools/suggest_next_actions

BODY json

{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/suggest_next_actions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/suggest_next_actions" {:content-type :json
                                                                           :form-params {:profile_id ""
                                                                                         :priority_level ""
                                                                                         :resource_availability ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/suggest_next_actions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/suggest_next_actions"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/suggest_next_actions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/suggest_next_actions"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/suggest_next_actions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/suggest_next_actions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/suggest_next_actions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/suggest_next_actions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/suggest_next_actions")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  priority_level: '',
  resource_availability: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/suggest_next_actions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/suggest_next_actions',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', priority_level: '', resource_availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/suggest_next_actions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","priority_level":"","resource_availability":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/suggest_next_actions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "priority_level": "",\n  "resource_availability": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/suggest_next_actions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/suggest_next_actions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', priority_level: '', resource_availability: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/suggest_next_actions',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', priority_level: '', resource_availability: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/suggest_next_actions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  priority_level: '',
  resource_availability: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/suggest_next_actions',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', priority_level: '', resource_availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/suggest_next_actions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","priority_level":"","resource_availability":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"priority_level": @"",
                              @"resource_availability": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/suggest_next_actions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/suggest_next_actions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/suggest_next_actions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'priority_level' => '',
    'resource_availability' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/suggest_next_actions', [
  'body' => '{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/suggest_next_actions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'priority_level' => '',
  'resource_availability' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'priority_level' => '',
  'resource_availability' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/suggest_next_actions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/suggest_next_actions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/suggest_next_actions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/suggest_next_actions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/suggest_next_actions"

payload = {
    "profile_id": "",
    "priority_level": "",
    "resource_availability": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/suggest_next_actions"

payload <- "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/suggest_next_actions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/suggest_next_actions') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"priority_level\": \"\",\n  \"resource_availability\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/suggest_next_actions";

    let payload = json!({
        "profile_id": "",
        "priority_level": "",
        "resource_availability": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/suggest_next_actions \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}'

echo '{
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
}' |  \
  http POST {{baseUrl}}/api/tools/suggest_next_actions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "priority_level": "",\n  "resource_availability": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/suggest_next_actions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "priority_level": "",
  "resource_availability": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/suggest_next_actions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get example requests for common tools

{{baseUrl}}/api/examples

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/examples");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/examples")

require "http/client"

url = "{{baseUrl}}/api/examples"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/examples"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/examples");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/examples"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/examples HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/examples")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/examples"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/examples")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/examples")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/examples');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/examples'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/examples';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/examples',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/examples")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/examples',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/examples'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/examples');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/examples'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/examples';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/examples"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/examples" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/examples",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/examples');

echo $response->getBody();

setUrl('{{baseUrl}}/api/examples');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/examples');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/examples' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/examples' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/examples")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/examples"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/examples"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/examples")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/examples') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/examples";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/examples

http GET {{baseUrl}}/api/examples

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/examples

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/examples")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Get implementation templates for subcategories

{{baseUrl}}/api/tools/get_implementation_template

BODY json

{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/get_implementation_template");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/get_implementation_template" {:content-type :json
                                                                                  :form-params {:subcategory_id ""
                                                                                                :industry ""
                                                                                                :organization_size ""
                                                                                                :include_examples false
                                                                                                :include_tools false
                                                                                                :include_metrics false}})

require "http/client"

url = "{{baseUrl}}/api/tools/get_implementation_template"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/get_implementation_template"),
    Content = new StringContent("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/get_implementation_template");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/get_implementation_template"

	payload := strings.NewReader("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/get_implementation_template HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 154

{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/get_implementation_template")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/get_implementation_template"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/get_implementation_template")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/get_implementation_template")
  .header("content-type", "application/json")
  .body("{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}")
  .asString();

const data = JSON.stringify({
  subcategory_id: '',
  industry: '',
  organization_size: '',
  include_examples: false,
  include_tools: false,
  include_metrics: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/get_implementation_template');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_implementation_template',
  headers: {'content-type': 'application/json'},
  data: {
    subcategory_id: '',
    industry: '',
    organization_size: '',
    include_examples: false,
    include_tools: false,
    include_metrics: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/get_implementation_template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","industry":"","organization_size":"","include_examples":false,"include_tools":false,"include_metrics":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/get_implementation_template',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "subcategory_id": "",\n  "industry": "",\n  "organization_size": "",\n  "include_examples": false,\n  "include_tools": false,\n  "include_metrics": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/get_implementation_template")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/get_implementation_template',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  subcategory_id: '',
  industry: '',
  organization_size: '',
  include_examples: false,
  include_tools: false,
  include_metrics: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_implementation_template',
  headers: {'content-type': 'application/json'},
  body: {
    subcategory_id: '',
    industry: '',
    organization_size: '',
    include_examples: false,
    include_tools: false,
    include_metrics: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/get_implementation_template');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  subcategory_id: '',
  industry: '',
  organization_size: '',
  include_examples: false,
  include_tools: false,
  include_metrics: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_implementation_template',
  headers: {'content-type': 'application/json'},
  data: {
    subcategory_id: '',
    industry: '',
    organization_size: '',
    include_examples: false,
    include_tools: false,
    include_metrics: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/get_implementation_template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","industry":"","organization_size":"","include_examples":false,"include_tools":false,"include_metrics":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"subcategory_id": @"",
                              @"industry": @"",
                              @"organization_size": @"",
                              @"include_examples": @NO,
                              @"include_tools": @NO,
                              @"include_metrics": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/get_implementation_template"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/get_implementation_template" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/get_implementation_template",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'subcategory_id' => '',
    'industry' => '',
    'organization_size' => '',
    'include_examples' => null,
    'include_tools' => null,
    'include_metrics' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/get_implementation_template', [
  'body' => '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/get_implementation_template');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'subcategory_id' => '',
  'industry' => '',
  'organization_size' => '',
  'include_examples' => null,
  'include_tools' => null,
  'include_metrics' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'subcategory_id' => '',
  'industry' => '',
  'organization_size' => '',
  'include_examples' => null,
  'include_tools' => null,
  'include_metrics' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/get_implementation_template');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/get_implementation_template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/get_implementation_template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/get_implementation_template", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/get_implementation_template"

payload = {
    "subcategory_id": "",
    "industry": "",
    "organization_size": "",
    "include_examples": False,
    "include_tools": False,
    "include_metrics": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/get_implementation_template"

payload <- "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/get_implementation_template")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/get_implementation_template') do |req|
  req.body = "{\n  \"subcategory_id\": \"\",\n  \"industry\": \"\",\n  \"organization_size\": \"\",\n  \"include_examples\": false,\n  \"include_tools\": false,\n  \"include_metrics\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/get_implementation_template";

    let payload = json!({
        "subcategory_id": "",
        "industry": "",
        "organization_size": "",
        "include_examples": false,
        "include_tools": false,
        "include_metrics": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/get_implementation_template \
  --header 'content-type: application/json' \
  --data '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}'

echo '{
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
}' |  \
  http POST {{baseUrl}}/api/tools/get_implementation_template \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "subcategory_id": "",\n  "industry": "",\n  "organization_size": "",\n  "include_examples": false,\n  "include_tools": false,\n  "include_metrics": false\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/get_implementation_template

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "subcategory_id": "",
  "industry": "",
  "organization_size": "",
  "include_examples": false,
  "include_tools": false,
  "include_metrics": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/get_implementation_template")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Get related CSF subcategories

{{baseUrl}}/api/tools/get_related_subcategories

BODY json

{
  "subcategory_id": "",
  "relationship_type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/get_related_subcategories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/get_related_subcategories" {:content-type :json
                                                                                :form-params {:subcategory_id ""
                                                                                              :relationship_type ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/get_related_subcategories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/get_related_subcategories"),
    Content = new StringContent("{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/get_related_subcategories");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/get_related_subcategories"

	payload := strings.NewReader("{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/get_related_subcategories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "subcategory_id": "",
  "relationship_type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/get_related_subcategories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/get_related_subcategories"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/get_related_subcategories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/get_related_subcategories")
  .header("content-type", "application/json")
  .body("{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  subcategory_id: '',
  relationship_type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/get_related_subcategories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_related_subcategories',
  headers: {'content-type': 'application/json'},
  data: {subcategory_id: '', relationship_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/get_related_subcategories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","relationship_type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/get_related_subcategories',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "subcategory_id": "",\n  "relationship_type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/get_related_subcategories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/get_related_subcategories',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({subcategory_id: '', relationship_type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_related_subcategories',
  headers: {'content-type': 'application/json'},
  body: {subcategory_id: '', relationship_type: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/get_related_subcategories');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  subcategory_id: '',
  relationship_type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_related_subcategories',
  headers: {'content-type': 'application/json'},
  data: {subcategory_id: '', relationship_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/get_related_subcategories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subcategory_id":"","relationship_type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"subcategory_id": @"",
                              @"relationship_type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/get_related_subcategories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/get_related_subcategories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/get_related_subcategories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'subcategory_id' => '',
    'relationship_type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/get_related_subcategories', [
  'body' => '{
  "subcategory_id": "",
  "relationship_type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/get_related_subcategories');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'subcategory_id' => '',
  'relationship_type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'subcategory_id' => '',
  'relationship_type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/get_related_subcategories');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/get_related_subcategories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "relationship_type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/get_related_subcategories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subcategory_id": "",
  "relationship_type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/get_related_subcategories", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/get_related_subcategories"

payload = {
    "subcategory_id": "",
    "relationship_type": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/get_related_subcategories"

payload <- "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/get_related_subcategories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/get_related_subcategories') do |req|
  req.body = "{\n  \"subcategory_id\": \"\",\n  \"relationship_type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/get_related_subcategories";

    let payload = json!({
        "subcategory_id": "",
        "relationship_type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/get_related_subcategories \
  --header 'content-type: application/json' \
  --data '{
  "subcategory_id": "",
  "relationship_type": ""
}'

echo '{
  "subcategory_id": "",
  "relationship_type": ""
}' |  \
  http POST {{baseUrl}}/api/tools/get_related_subcategories \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "subcategory_id": "",\n  "relationship_type": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/get_related_subcategories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "subcategory_id": "",
  "relationship_type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/get_related_subcategories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Import external assessment data

{{baseUrl}}/api/tools/import_assessment

BODY json

{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/import_assessment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/import_assessment" {:content-type :json
                                                                        :form-params {:profile_id ""
                                                                                      :assessment_data {}
                                                                                      :overwrite_existing false}})

require "http/client"

url = "{{baseUrl}}/api/tools/import_assessment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/import_assessment"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/import_assessment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/import_assessment"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/import_assessment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/import_assessment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/import_assessment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/import_assessment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/import_assessment")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  assessment_data: {},
  overwrite_existing: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/import_assessment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/import_assessment',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', assessment_data: {}, overwrite_existing: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/import_assessment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_data":{},"overwrite_existing":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/import_assessment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "assessment_data": {},\n  "overwrite_existing": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/import_assessment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/import_assessment',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', assessment_data: {}, overwrite_existing: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/import_assessment',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', assessment_data: {}, overwrite_existing: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/import_assessment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  assessment_data: {},
  overwrite_existing: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/import_assessment',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', assessment_data: {}, overwrite_existing: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/import_assessment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_data":{},"overwrite_existing":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"assessment_data": @{  },
                              @"overwrite_existing": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/import_assessment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/import_assessment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/import_assessment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'assessment_data' => [
        
    ],
    'overwrite_existing' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/import_assessment', [
  'body' => '{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/import_assessment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'assessment_data' => [
    
  ],
  'overwrite_existing' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'assessment_data' => [
    
  ],
  'overwrite_existing' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/import_assessment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/import_assessment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/import_assessment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/import_assessment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/import_assessment"

payload = {
    "profile_id": "",
    "assessment_data": {},
    "overwrite_existing": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/import_assessment"

payload <- "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/import_assessment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/import_assessment') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"assessment_data\": {},\n  \"overwrite_existing\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/import_assessment";

    let payload = json!({
        "profile_id": "",
        "assessment_data": json!({}),
        "overwrite_existing": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/import_assessment \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}'

echo '{
  "profile_id": "",
  "assessment_data": {},
  "overwrite_existing": false
}' |  \
  http POST {{baseUrl}}/api/tools/import_assessment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "assessment_data": {},\n  "overwrite_existing": false\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/import_assessment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "assessment_data": [],
  "overwrite_existing": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/import_assessment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List all available MCP tools

{{baseUrl}}/api/tools

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/tools")

require "http/client"

url = "{{baseUrl}}/api/tools"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/tools"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/tools HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/tools")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/tools")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/tools');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/tools'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/tools")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/tools'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/tools');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/tools'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/tools');

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/tools');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/tools")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/tools') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/tools

http GET {{baseUrl}}/api/tools

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/tools

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Look up NIST CSF 2.0 framework element by ID

{{baseUrl}}/api/tools/csf_lookup

BODY json

{
  "element_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/csf_lookup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"element_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/csf_lookup" {:content-type :json
                                                                 :form-params {:element_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/csf_lookup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"element_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/csf_lookup"),
    Content = new StringContent("{\n  \"element_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/csf_lookup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"element_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/csf_lookup"

	payload := strings.NewReader("{\n  \"element_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/csf_lookup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "element_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/csf_lookup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"element_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/csf_lookup"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"element_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"element_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/csf_lookup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/csf_lookup")
  .header("content-type", "application/json")
  .body("{\n  \"element_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  element_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/csf_lookup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/csf_lookup',
  headers: {'content-type': 'application/json'},
  data: {element_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/csf_lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"element_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/csf_lookup',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "element_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"element_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/csf_lookup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/csf_lookup',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({element_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/csf_lookup',
  headers: {'content-type': 'application/json'},
  body: {element_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/csf_lookup');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  element_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/csf_lookup',
  headers: {'content-type': 'application/json'},
  data: {element_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/csf_lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"element_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"element_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/csf_lookup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/csf_lookup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"element_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/csf_lookup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'element_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/csf_lookup', [
  'body' => '{
  "element_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/csf_lookup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'element_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'element_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/csf_lookup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/csf_lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "element_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/csf_lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "element_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"element_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/csf_lookup", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/csf_lookup"

payload = { "element_id": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/csf_lookup"

payload <- "{\n  \"element_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/csf_lookup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"element_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/csf_lookup') do |req|
  req.body = "{\n  \"element_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/csf_lookup";

    let payload = json!({"element_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/csf_lookup \
  --header 'content-type: application/json' \
  --data '{
  "element_id": ""
}'

echo '{
  "element_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/csf_lookup \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "element_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/csf_lookup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["element_id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/csf_lookup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Perform a comprehensive maturity assessment

{{baseUrl}}/api/tools/assess_maturity

BODY json

{
  "profile_id": "",
  "assessment_scope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/assess_maturity");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/assess_maturity" {:content-type :json
                                                                      :form-params {:profile_id ""
                                                                                    :assessment_scope ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/assess_maturity"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/assess_maturity"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/assess_maturity");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/assess_maturity"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/assess_maturity HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "profile_id": "",
  "assessment_scope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/assess_maturity")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/assess_maturity"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/assess_maturity")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/assess_maturity")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  assessment_scope: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/assess_maturity');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/assess_maturity',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', assessment_scope: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/assess_maturity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_scope":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/assess_maturity',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "assessment_scope": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/assess_maturity")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/assess_maturity',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', assessment_scope: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/assess_maturity',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', assessment_scope: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/assess_maturity');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  assessment_scope: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/assess_maturity',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', assessment_scope: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/assess_maturity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_scope":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"assessment_scope": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/assess_maturity"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/assess_maturity" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/assess_maturity",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'assessment_scope' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/assess_maturity', [
  'body' => '{
  "profile_id": "",
  "assessment_scope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/assess_maturity');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'assessment_scope' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'assessment_scope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/assess_maturity');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/assess_maturity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_scope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/assess_maturity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_scope": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/assess_maturity", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/assess_maturity"

payload = {
    "profile_id": "",
    "assessment_scope": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/assess_maturity"

payload <- "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/assess_maturity")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/assess_maturity') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"assessment_scope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/assess_maturity";

    let payload = json!({
        "profile_id": "",
        "assessment_scope": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/assess_maturity \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "assessment_scope": ""
}'

echo '{
  "profile_id": "",
  "assessment_scope": ""
}' |  \
  http POST {{baseUrl}}/api/tools/assess_maturity \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "assessment_scope": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/assess_maturity

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "assessment_scope": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/assess_maturity")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Retrieve assessment questions for subcategories

{{baseUrl}}/api/tools/get_assessment_questions

BODY json

{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/get_assessment_questions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/get_assessment_questions" {:content-type :json
                                                                               :form-params {:assessment_type ""
                                                                                             :organization_size ""
                                                                                             :subcategory_ids []}})

require "http/client"

url = "{{baseUrl}}/api/tools/get_assessment_questions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/get_assessment_questions"),
    Content = new StringContent("{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/get_assessment_questions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/get_assessment_questions"

	payload := strings.NewReader("{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/get_assessment_questions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/get_assessment_questions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/get_assessment_questions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/get_assessment_questions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/get_assessment_questions")
  .header("content-type", "application/json")
  .body("{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}")
  .asString();

const data = JSON.stringify({
  assessment_type: '',
  organization_size: '',
  subcategory_ids: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/get_assessment_questions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_assessment_questions',
  headers: {'content-type': 'application/json'},
  data: {assessment_type: '', organization_size: '', subcategory_ids: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/get_assessment_questions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assessment_type":"","organization_size":"","subcategory_ids":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/get_assessment_questions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assessment_type": "",\n  "organization_size": "",\n  "subcategory_ids": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/get_assessment_questions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/get_assessment_questions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assessment_type: '', organization_size: '', subcategory_ids: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_assessment_questions',
  headers: {'content-type': 'application/json'},
  body: {assessment_type: '', organization_size: '', subcategory_ids: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/get_assessment_questions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assessment_type: '',
  organization_size: '',
  subcategory_ids: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_assessment_questions',
  headers: {'content-type': 'application/json'},
  data: {assessment_type: '', organization_size: '', subcategory_ids: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/get_assessment_questions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assessment_type":"","organization_size":"","subcategory_ids":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assessment_type": @"",
                              @"organization_size": @"",
                              @"subcategory_ids": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/get_assessment_questions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/get_assessment_questions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/get_assessment_questions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assessment_type' => '',
    'organization_size' => '',
    'subcategory_ids' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/get_assessment_questions', [
  'body' => '{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/get_assessment_questions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assessment_type' => '',
  'organization_size' => '',
  'subcategory_ids' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assessment_type' => '',
  'organization_size' => '',
  'subcategory_ids' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/get_assessment_questions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/get_assessment_questions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/get_assessment_questions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/get_assessment_questions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/get_assessment_questions"

payload = {
    "assessment_type": "",
    "organization_size": "",
    "subcategory_ids": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/get_assessment_questions"

payload <- "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/get_assessment_questions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/get_assessment_questions') do |req|
  req.body = "{\n  \"assessment_type\": \"\",\n  \"organization_size\": \"\",\n  \"subcategory_ids\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/get_assessment_questions";

    let payload = json!({
        "assessment_type": "",
        "organization_size": "",
        "subcategory_ids": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/get_assessment_questions \
  --header 'content-type: application/json' \
  --data '{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}'

echo '{
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
}' |  \
  http POST {{baseUrl}}/api/tools/get_assessment_questions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assessment_type": "",\n  "organization_size": "",\n  "subcategory_ids": []\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/get_assessment_questions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assessment_type": "",
  "organization_size": "",
  "subcategory_ids": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/get_assessment_questions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Retrieve industry benchmark data for a profile

{{baseUrl}}/api/tools/get_industry_benchmarks

BODY json

{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/get_industry_benchmarks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/get_industry_benchmarks" {:content-type :json
                                                                              :form-params {:profile_id ""
                                                                                            :sector ""
                                                                                            :organization_size ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/get_industry_benchmarks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/get_industry_benchmarks"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/get_industry_benchmarks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/get_industry_benchmarks"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/get_industry_benchmarks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/get_industry_benchmarks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/get_industry_benchmarks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/get_industry_benchmarks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/get_industry_benchmarks")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  sector: '',
  organization_size: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/get_industry_benchmarks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_industry_benchmarks',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', sector: '', organization_size: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/get_industry_benchmarks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","sector":"","organization_size":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/get_industry_benchmarks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "sector": "",\n  "organization_size": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/get_industry_benchmarks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/get_industry_benchmarks',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', sector: '', organization_size: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_industry_benchmarks',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', sector: '', organization_size: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/get_industry_benchmarks');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  sector: '',
  organization_size: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/get_industry_benchmarks',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', sector: '', organization_size: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/get_industry_benchmarks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","sector":"","organization_size":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"sector": @"",
                              @"organization_size": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/get_industry_benchmarks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/get_industry_benchmarks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/get_industry_benchmarks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'sector' => '',
    'organization_size' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/get_industry_benchmarks', [
  'body' => '{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/get_industry_benchmarks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'sector' => '',
  'organization_size' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'sector' => '',
  'organization_size' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/get_industry_benchmarks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/get_industry_benchmarks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/get_industry_benchmarks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/get_industry_benchmarks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/get_industry_benchmarks"

payload = {
    "profile_id": "",
    "sector": "",
    "organization_size": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/get_industry_benchmarks"

payload <- "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/get_industry_benchmarks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/get_industry_benchmarks') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"sector\": \"\",\n  \"organization_size\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/get_industry_benchmarks";

    let payload = json!({
        "profile_id": "",
        "sector": "",
        "organization_size": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/get_industry_benchmarks \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}'

echo '{
  "profile_id": "",
  "sector": "",
  "organization_size": ""
}' |  \
  http POST {{baseUrl}}/api/tools/get_industry_benchmarks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "sector": "",\n  "organization_size": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/get_industry_benchmarks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "sector": "",
  "organization_size": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/get_industry_benchmarks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Search CSF framework elements by keyword

{{baseUrl}}/api/tools/search_framework

BODY json

{
  "query": "",
  "limit": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/search_framework");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"query\": \"\",\n  \"limit\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/search_framework" {:content-type :json
                                                                       :form-params {:query ""
                                                                                     :limit 0}})

require "http/client"

url = "{{baseUrl}}/api/tools/search_framework"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"query\": \"\",\n  \"limit\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/search_framework"),
    Content = new StringContent("{\n  \"query\": \"\",\n  \"limit\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/search_framework");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"query\": \"\",\n  \"limit\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/search_framework"

	payload := strings.NewReader("{\n  \"query\": \"\",\n  \"limit\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/search_framework HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "query": "",
  "limit": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/search_framework")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"query\": \"\",\n  \"limit\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/search_framework"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"query\": \"\",\n  \"limit\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"query\": \"\",\n  \"limit\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/search_framework")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/search_framework")
  .header("content-type", "application/json")
  .body("{\n  \"query\": \"\",\n  \"limit\": 0\n}")
  .asString();

const data = JSON.stringify({
  query: '',
  limit: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/search_framework');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/search_framework',
  headers: {'content-type': 'application/json'},
  data: {query: '', limit: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/search_framework';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"query":"","limit":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/search_framework',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "query": "",\n  "limit": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"query\": \"\",\n  \"limit\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/search_framework")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/search_framework',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({query: '', limit: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/search_framework',
  headers: {'content-type': 'application/json'},
  body: {query: '', limit: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/search_framework');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  query: '',
  limit: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/search_framework',
  headers: {'content-type': 'application/json'},
  data: {query: '', limit: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/search_framework';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"query":"","limit":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"query": @"",
                              @"limit": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/search_framework"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/search_framework" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"query\": \"\",\n  \"limit\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/search_framework",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'query' => '',
    'limit' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/search_framework', [
  'body' => '{
  "query": "",
  "limit": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/search_framework');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'query' => '',
  'limit' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'query' => '',
  'limit' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/search_framework');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/search_framework' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "query": "",
  "limit": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/search_framework' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "query": "",
  "limit": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"query\": \"\",\n  \"limit\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/search_framework", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/search_framework"

payload = {
    "query": "",
    "limit": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/search_framework"

payload <- "{\n  \"query\": \"\",\n  \"limit\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/search_framework")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"query\": \"\",\n  \"limit\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/search_framework') do |req|
  req.body = "{\n  \"query\": \"\",\n  \"limit\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/search_framework";

    let payload = json!({
        "query": "",
        "limit": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/search_framework \
  --header 'content-type: application/json' \
  --data '{
  "query": "",
  "limit": 0
}'

echo '{
  "query": "",
  "limit": 0
}' |  \
  http POST {{baseUrl}}/api/tools/search_framework \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "query": "",\n  "limit": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/search_framework

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "query": "",
  "limit": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/search_framework")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Start a new assessment workflow

{{baseUrl}}/api/tools/start_assessment_workflow

BODY json

{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/start_assessment_workflow");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/start_assessment_workflow" {:content-type :json
                                                                                :form-params {:org_name ""
                                                                                              :sector ""
                                                                                              :size ""
                                                                                              :contact_name ""
                                                                                              :contact_email ""
                                                                                              :assessment_scope ""
                                                                                              :timeline_weeks 0}})

require "http/client"

url = "{{baseUrl}}/api/tools/start_assessment_workflow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/start_assessment_workflow"),
    Content = new StringContent("{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/start_assessment_workflow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/start_assessment_workflow"

	payload := strings.NewReader("{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/start_assessment_workflow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 144

{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/start_assessment_workflow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/start_assessment_workflow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/start_assessment_workflow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/start_assessment_workflow")
  .header("content-type", "application/json")
  .body("{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}")
  .asString();

const data = JSON.stringify({
  org_name: '',
  sector: '',
  size: '',
  contact_name: '',
  contact_email: '',
  assessment_scope: '',
  timeline_weeks: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/start_assessment_workflow');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/start_assessment_workflow',
  headers: {'content-type': 'application/json'},
  data: {
    org_name: '',
    sector: '',
    size: '',
    contact_name: '',
    contact_email: '',
    assessment_scope: '',
    timeline_weeks: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/start_assessment_workflow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"org_name":"","sector":"","size":"","contact_name":"","contact_email":"","assessment_scope":"","timeline_weeks":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/start_assessment_workflow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "org_name": "",\n  "sector": "",\n  "size": "",\n  "contact_name": "",\n  "contact_email": "",\n  "assessment_scope": "",\n  "timeline_weeks": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/start_assessment_workflow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/start_assessment_workflow',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  org_name: '',
  sector: '',
  size: '',
  contact_name: '',
  contact_email: '',
  assessment_scope: '',
  timeline_weeks: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/start_assessment_workflow',
  headers: {'content-type': 'application/json'},
  body: {
    org_name: '',
    sector: '',
    size: '',
    contact_name: '',
    contact_email: '',
    assessment_scope: '',
    timeline_weeks: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/start_assessment_workflow');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  org_name: '',
  sector: '',
  size: '',
  contact_name: '',
  contact_email: '',
  assessment_scope: '',
  timeline_weeks: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/start_assessment_workflow',
  headers: {'content-type': 'application/json'},
  data: {
    org_name: '',
    sector: '',
    size: '',
    contact_name: '',
    contact_email: '',
    assessment_scope: '',
    timeline_weeks: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/start_assessment_workflow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"org_name":"","sector":"","size":"","contact_name":"","contact_email":"","assessment_scope":"","timeline_weeks":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"org_name": @"",
                              @"sector": @"",
                              @"size": @"",
                              @"contact_name": @"",
                              @"contact_email": @"",
                              @"assessment_scope": @"",
                              @"timeline_weeks": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/start_assessment_workflow"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/start_assessment_workflow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/start_assessment_workflow",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'org_name' => '',
    'sector' => '',
    'size' => '',
    'contact_name' => '',
    'contact_email' => '',
    'assessment_scope' => '',
    'timeline_weeks' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/start_assessment_workflow', [
  'body' => '{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/start_assessment_workflow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'org_name' => '',
  'sector' => '',
  'size' => '',
  'contact_name' => '',
  'contact_email' => '',
  'assessment_scope' => '',
  'timeline_weeks' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'org_name' => '',
  'sector' => '',
  'size' => '',
  'contact_name' => '',
  'contact_email' => '',
  'assessment_scope' => '',
  'timeline_weeks' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/start_assessment_workflow');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/start_assessment_workflow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/start_assessment_workflow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/start_assessment_workflow", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/start_assessment_workflow"

payload = {
    "org_name": "",
    "sector": "",
    "size": "",
    "contact_name": "",
    "contact_email": "",
    "assessment_scope": "",
    "timeline_weeks": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/start_assessment_workflow"

payload <- "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/start_assessment_workflow")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/start_assessment_workflow') do |req|
  req.body = "{\n  \"org_name\": \"\",\n  \"sector\": \"\",\n  \"size\": \"\",\n  \"contact_name\": \"\",\n  \"contact_email\": \"\",\n  \"assessment_scope\": \"\",\n  \"timeline_weeks\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/start_assessment_workflow";

    let payload = json!({
        "org_name": "",
        "sector": "",
        "size": "",
        "contact_name": "",
        "contact_email": "",
        "assessment_scope": "",
        "timeline_weeks": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/start_assessment_workflow \
  --header 'content-type: application/json' \
  --data '{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}'

echo '{
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
}' |  \
  http POST {{baseUrl}}/api/tools/start_assessment_workflow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "org_name": "",\n  "sector": "",\n  "size": "",\n  "contact_name": "",\n  "contact_email": "",\n  "assessment_scope": "",\n  "timeline_weeks": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/start_assessment_workflow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "org_name": "",
  "sector": "",
  "size": "",
  "contact_name": "",
  "contact_email": "",
  "assessment_scope": "",
  "timeline_weeks": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/start_assessment_workflow")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Update and track implementation progress

{{baseUrl}}/api/tools/track_progress

BODY json

{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/track_progress");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/track_progress" {:content-type :json
                                                                     :form-params {:profile_id ""
                                                                                   :updates [{:subcategory_id ""
                                                                                              :current_implementation ""
                                                                                              :current_maturity 0
                                                                                              :status ""
                                                                                              :notes ""}]}})

require "http/client"

url = "{{baseUrl}}/api/tools/track_progress"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/track_progress"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/track_progress");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/track_progress"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/track_progress HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 185

{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/track_progress")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/track_progress"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/track_progress")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/track_progress")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  updates: [
    {
      subcategory_id: '',
      current_implementation: '',
      current_maturity: 0,
      status: '',
      notes: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/track_progress');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/track_progress',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    updates: [
      {
        subcategory_id: '',
        current_implementation: '',
        current_maturity: 0,
        status: '',
        notes: ''
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/track_progress';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","updates":[{"subcategory_id":"","current_implementation":"","current_maturity":0,"status":"","notes":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/track_progress',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "updates": [\n    {\n      "subcategory_id": "",\n      "current_implementation": "",\n      "current_maturity": 0,\n      "status": "",\n      "notes": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/track_progress")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/track_progress',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  profile_id: '',
  updates: [
    {
      subcategory_id: '',
      current_implementation: '',
      current_maturity: 0,
      status: '',
      notes: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/track_progress',
  headers: {'content-type': 'application/json'},
  body: {
    profile_id: '',
    updates: [
      {
        subcategory_id: '',
        current_implementation: '',
        current_maturity: 0,
        status: '',
        notes: ''
      }
    ]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/track_progress');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  updates: [
    {
      subcategory_id: '',
      current_implementation: '',
      current_maturity: 0,
      status: '',
      notes: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/track_progress',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    updates: [
      {
        subcategory_id: '',
        current_implementation: '',
        current_maturity: 0,
        status: '',
        notes: ''
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/track_progress';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","updates":[{"subcategory_id":"","current_implementation":"","current_maturity":0,"status":"","notes":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"updates": @[ @{ @"subcategory_id": @"", @"current_implementation": @"", @"current_maturity": @0, @"status": @"", @"notes": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/track_progress"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/track_progress" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/track_progress",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'updates' => [
        [
                'subcategory_id' => '',
                'current_implementation' => '',
                'current_maturity' => 0,
                'status' => '',
                'notes' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/track_progress', [
  'body' => '{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/track_progress');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'updates' => [
    [
        'subcategory_id' => '',
        'current_implementation' => '',
        'current_maturity' => 0,
        'status' => '',
        'notes' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'updates' => [
    [
        'subcategory_id' => '',
        'current_implementation' => '',
        'current_maturity' => 0,
        'status' => '',
        'notes' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/track_progress');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/track_progress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/track_progress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/track_progress", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/track_progress"

payload = {
    "profile_id": "",
    "updates": [
        {
            "subcategory_id": "",
            "current_implementation": "",
            "current_maturity": 0,
            "status": "",
            "notes": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/track_progress"

payload <- "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/track_progress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/track_progress') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"updates\": [\n    {\n      \"subcategory_id\": \"\",\n      \"current_implementation\": \"\",\n      \"current_maturity\": 0,\n      \"status\": \"\",\n      \"notes\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/track_progress";

    let payload = json!({
        "profile_id": "",
        "updates": (
            json!({
                "subcategory_id": "",
                "current_implementation": "",
                "current_maturity": 0,
                "status": "",
                "notes": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/track_progress \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}'

echo '{
  "profile_id": "",
  "updates": [
    {
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/api/tools/track_progress \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "updates": [\n    {\n      "subcategory_id": "",\n      "current_implementation": "",\n      "current_maturity": 0,\n      "status": "",\n      "notes": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/track_progress

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "updates": [
    [
      "subcategory_id": "",
      "current_implementation": "",
      "current_maturity": 0,
      "status": "",
      "notes": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/track_progress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Validate responses submitted for assessment

{{baseUrl}}/api/tools/validate_assessment_responses

BODY json

{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/validate_assessment_responses");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/validate_assessment_responses" {:content-type :json
                                                                                    :form-params {:profile_id ""
                                                                                                  :assessment_type ""
                                                                                                  :responses [{:subcategory_id ""
                                                                                                               :response_value ""
                                                                                                               :evidence ""
                                                                                                               :assessed_by ""
                                                                                                               :confidence_level ""}]
                                                                                                  :require_all_questions false
                                                                                                  :allow_partial_responses false}})

require "http/client"

url = "{{baseUrl}}/api/tools/validate_assessment_responses"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/validate_assessment_responses"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/validate_assessment_responses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/validate_assessment_responses"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/validate_assessment_responses HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 283

{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/validate_assessment_responses")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/validate_assessment_responses"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/validate_assessment_responses")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/validate_assessment_responses")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  assessment_type: '',
  responses: [
    {
      subcategory_id: '',
      response_value: '',
      evidence: '',
      assessed_by: '',
      confidence_level: ''
    }
  ],
  require_all_questions: false,
  allow_partial_responses: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/validate_assessment_responses');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_assessment_responses',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    assessment_type: '',
    responses: [
      {
        subcategory_id: '',
        response_value: '',
        evidence: '',
        assessed_by: '',
        confidence_level: ''
      }
    ],
    require_all_questions: false,
    allow_partial_responses: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/validate_assessment_responses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_type":"","responses":[{"subcategory_id":"","response_value":"","evidence":"","assessed_by":"","confidence_level":""}],"require_all_questions":false,"allow_partial_responses":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/validate_assessment_responses',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "assessment_type": "",\n  "responses": [\n    {\n      "subcategory_id": "",\n      "response_value": "",\n      "evidence": "",\n      "assessed_by": "",\n      "confidence_level": ""\n    }\n  ],\n  "require_all_questions": false,\n  "allow_partial_responses": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/validate_assessment_responses")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/validate_assessment_responses',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  profile_id: '',
  assessment_type: '',
  responses: [
    {
      subcategory_id: '',
      response_value: '',
      evidence: '',
      assessed_by: '',
      confidence_level: ''
    }
  ],
  require_all_questions: false,
  allow_partial_responses: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_assessment_responses',
  headers: {'content-type': 'application/json'},
  body: {
    profile_id: '',
    assessment_type: '',
    responses: [
      {
        subcategory_id: '',
        response_value: '',
        evidence: '',
        assessed_by: '',
        confidence_level: ''
      }
    ],
    require_all_questions: false,
    allow_partial_responses: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/validate_assessment_responses');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  assessment_type: '',
  responses: [
    {
      subcategory_id: '',
      response_value: '',
      evidence: '',
      assessed_by: '',
      confidence_level: ''
    }
  ],
  require_all_questions: false,
  allow_partial_responses: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_assessment_responses',
  headers: {'content-type': 'application/json'},
  data: {
    profile_id: '',
    assessment_type: '',
    responses: [
      {
        subcategory_id: '',
        response_value: '',
        evidence: '',
        assessed_by: '',
        confidence_level: ''
      }
    ],
    require_all_questions: false,
    allow_partial_responses: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/validate_assessment_responses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","assessment_type":"","responses":[{"subcategory_id":"","response_value":"","evidence":"","assessed_by":"","confidence_level":""}],"require_all_questions":false,"allow_partial_responses":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"assessment_type": @"",
                              @"responses": @[ @{ @"subcategory_id": @"", @"response_value": @"", @"evidence": @"", @"assessed_by": @"", @"confidence_level": @"" } ],
                              @"require_all_questions": @NO,
                              @"allow_partial_responses": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/validate_assessment_responses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/validate_assessment_responses" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/validate_assessment_responses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'assessment_type' => '',
    'responses' => [
        [
                'subcategory_id' => '',
                'response_value' => '',
                'evidence' => '',
                'assessed_by' => '',
                'confidence_level' => ''
        ]
    ],
    'require_all_questions' => null,
    'allow_partial_responses' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/validate_assessment_responses', [
  'body' => '{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/validate_assessment_responses');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'assessment_type' => '',
  'responses' => [
    [
        'subcategory_id' => '',
        'response_value' => '',
        'evidence' => '',
        'assessed_by' => '',
        'confidence_level' => ''
    ]
  ],
  'require_all_questions' => null,
  'allow_partial_responses' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'assessment_type' => '',
  'responses' => [
    [
        'subcategory_id' => '',
        'response_value' => '',
        'evidence' => '',
        'assessed_by' => '',
        'confidence_level' => ''
    ]
  ],
  'require_all_questions' => null,
  'allow_partial_responses' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/validate_assessment_responses');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/validate_assessment_responses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/validate_assessment_responses' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/validate_assessment_responses", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/validate_assessment_responses"

payload = {
    "profile_id": "",
    "assessment_type": "",
    "responses": [
        {
            "subcategory_id": "",
            "response_value": "",
            "evidence": "",
            "assessed_by": "",
            "confidence_level": ""
        }
    ],
    "require_all_questions": False,
    "allow_partial_responses": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/validate_assessment_responses"

payload <- "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/validate_assessment_responses")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/validate_assessment_responses') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"assessment_type\": \"\",\n  \"responses\": [\n    {\n      \"subcategory_id\": \"\",\n      \"response_value\": \"\",\n      \"evidence\": \"\",\n      \"assessed_by\": \"\",\n      \"confidence_level\": \"\"\n    }\n  ],\n  \"require_all_questions\": false,\n  \"allow_partial_responses\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/validate_assessment_responses";

    let payload = json!({
        "profile_id": "",
        "assessment_type": "",
        "responses": (
            json!({
                "subcategory_id": "",
                "response_value": "",
                "evidence": "",
                "assessed_by": "",
                "confidence_level": ""
            })
        ),
        "require_all_questions": false,
        "allow_partial_responses": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/validate_assessment_responses \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}'

echo '{
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    {
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    }
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
}' |  \
  http POST {{baseUrl}}/api/tools/validate_assessment_responses \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "assessment_type": "",\n  "responses": [\n    {\n      "subcategory_id": "",\n      "response_value": "",\n      "evidence": "",\n      "assessed_by": "",\n      "confidence_level": ""\n    }\n  ],\n  "require_all_questions": false,\n  "allow_partial_responses": false\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/validate_assessment_responses

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "assessment_type": "",
  "responses": [
    [
      "subcategory_id": "",
      "response_value": "",
      "evidence": "",
      "assessed_by": "",
      "confidence_level": ""
    ]
  ],
  "require_all_questions": false,
  "allow_partial_responses": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/validate_assessment_responses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Validate submitted evidence for assessment

{{baseUrl}}/api/tools/validate_evidence

BODY json

{
  "profile_id": "",
  "evidence_id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/tools/validate_evidence");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/tools/validate_evidence" {:content-type :json
                                                                        :form-params {:profile_id ""
                                                                                      :evidence_id ""}})

require "http/client"

url = "{{baseUrl}}/api/tools/validate_evidence"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/tools/validate_evidence"),
    Content = new StringContent("{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/tools/validate_evidence");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/tools/validate_evidence"

	payload := strings.NewReader("{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/tools/validate_evidence HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "profile_id": "",
  "evidence_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/tools/validate_evidence")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/tools/validate_evidence"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/tools/validate_evidence")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/tools/validate_evidence")
  .header("content-type", "application/json")
  .body("{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  profile_id: '',
  evidence_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/tools/validate_evidence');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_evidence',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', evidence_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/tools/validate_evidence';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","evidence_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/tools/validate_evidence',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "profile_id": "",\n  "evidence_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/tools/validate_evidence")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/tools/validate_evidence',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({profile_id: '', evidence_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_evidence',
  headers: {'content-type': 'application/json'},
  body: {profile_id: '', evidence_id: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/tools/validate_evidence');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  profile_id: '',
  evidence_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/tools/validate_evidence',
  headers: {'content-type': 'application/json'},
  data: {profile_id: '', evidence_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/tools/validate_evidence';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"profile_id":"","evidence_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"profile_id": @"",
                              @"evidence_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/tools/validate_evidence"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/tools/validate_evidence" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/tools/validate_evidence",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'profile_id' => '',
    'evidence_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/tools/validate_evidence', [
  'body' => '{
  "profile_id": "",
  "evidence_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/tools/validate_evidence');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'profile_id' => '',
  'evidence_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'profile_id' => '',
  'evidence_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/tools/validate_evidence');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/tools/validate_evidence' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "evidence_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/tools/validate_evidence' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "profile_id": "",
  "evidence_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/tools/validate_evidence", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/tools/validate_evidence"

payload = {
    "profile_id": "",
    "evidence_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/tools/validate_evidence"

payload <- "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/tools/validate_evidence")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/tools/validate_evidence') do |req|
  req.body = "{\n  \"profile_id\": \"\",\n  \"evidence_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/tools/validate_evidence";

    let payload = json!({
        "profile_id": "",
        "evidence_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/tools/validate_evidence \
  --header 'content-type: application/json' \
  --data '{
  "profile_id": "",
  "evidence_id": ""
}'

echo '{
  "profile_id": "",
  "evidence_id": ""
}' |  \
  http POST {{baseUrl}}/api/tools/validate_evidence \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "profile_id": "",\n  "evidence_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/tools/validate_evidence

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "profile_id": "",
  "evidence_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/tools/validate_evidence")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

NIST CSF 2.0 MCP Server API