Content Moderator Client
Content Moderator Clientv1.0
You use the API to scan your content as it is generated. Content Moderator then processes your content and sends the results along with relevant information either back to your systems or to the built-in review tool. You can use this information to take decisions e.g. take it down, send to human judge, etc. When using the API, images need to have a minimum of 128 pixels and a maximum file size of 4MB. Text can be at most 1024 characters long. If the content passed to the text API or the image API exceeds the size limits, the API will return an error code that informs about the issue.
- Endpoints
- 35 (16 POST, 9 GET, 6 DELETE, 4 PUT)
- Base URL
https://azure.local- Authentication
- API key
- Spec format
- Swagger 2.0
- API version
- 1.0
- Provider
- azure.com
- Categories
- Cloud & Infrastructure
- Last updated
Use this API in Bruno:
- Download the Bruno collection above and unzip it.
- In Bruno, choose Open Collection and select the unzipped folder.
- Set the
baseUrlvariable (for examplehttps://azure.local) and your API key credentials, then send requests.
POST
ImageModeration_Evaluate
{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Evaluate HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"))
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Evaluate',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate');
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}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Evaluate') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluatehttp POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluatewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Evaluate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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
ImageModeration_FindFaces
{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessImage/FindFaces HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"))
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/FindFaces',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces');
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}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/FindFaces') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaceshttp POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaceswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFacesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/FindFaces")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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
ImageModeration_Match
{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Match HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"))
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessImage/Match")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/Match',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Match',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match');
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}}/contentmoderator/moderate/v1.0/ProcessImage/Match'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/Match"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/moderate/v1.0/ProcessImage/Match" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Match")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/Match') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Matchhttp POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Matchwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Matchimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/Match")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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
ImageModeration_OCR
{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessImage/OCR HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"))
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/OCR',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/OCR',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR');
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}}/contentmoderator/moderate/v1.0/ProcessImage/OCR'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR';
const options = {method: 'POST'};
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}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/moderate/v1.0/ProcessImage/OCR" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/OCR")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessImage/OCR') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCRhttp POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCRwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCRimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessImage/OCR")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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
ListManagementImage_AddImage
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"))
.method("POST", 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}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imageshttp POST {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imageswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imagesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
DELETE
ListManagementImage_DeleteAllImages
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imageshttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imageswget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imagesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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()
DELETE
ListManagementImage_DeleteImage
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageIdhttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageIdwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images/:ImageId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
ListManagementImage_GetAllImageIds
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
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/contentmoderator/lists/v1.0/imagelists/:listId/images HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"))
.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}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.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}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images',
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images';
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images"]
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images",
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}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/images') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images";
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}}/contentmoderator/lists/v1.0/imagelists/:listId/imageshttp GET {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imageswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/imagesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/images")! 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
ListManagementImageLists_Create
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/imagelists HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"))
.header("content-type", "")
.method("POST", 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}}/contentmoderator/lists/v1.0/imagelists")
.post(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.header("content-type", "")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists';
const options = {method: 'POST', headers: {'content-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}}/contentmoderator/lists/v1.0/imagelists',
method: 'POST',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.post(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists',
headers: {
'content-type': ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
req.headers({
'content-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}}/contentmoderator/lists/v1.0/imagelists',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists';
const options = {method: 'POST', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/lists/v1.0/imagelists" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
$request->setRequestMethod('POST');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists' -Method POST -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/imagelists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
headers = {"content-type": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/imagelists') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists \
--header 'content-type: 'http POST {{baseUrl}}/contentmoderator/lists/v1.0/imagelists \
content-type:''wget --quiet \
--method POST \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelistsimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()
DELETE
ListManagementImageLists_Delete
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/imagelists/:listId")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/imagelists/:listId" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdhttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
ListManagementImageLists_GetAllImageLists
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
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/contentmoderator/lists/v1.0/imagelists HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"))
.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}}/contentmoderator/lists/v1.0/imagelists")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.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}}/contentmoderator/lists/v1.0/imagelists');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists';
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}}/contentmoderator/lists/v1.0/imagelists',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists',
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}}/contentmoderator/lists/v1.0/imagelists'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
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}}/contentmoderator/lists/v1.0/imagelists'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists';
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}}/contentmoderator/lists/v1.0/imagelists"]
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}}/contentmoderator/lists/v1.0/imagelists" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists",
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}}/contentmoderator/lists/v1.0/imagelists');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/imagelists")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/imagelists') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists";
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}}/contentmoderator/lists/v1.0/imagelistshttp GET {{baseUrl}}/contentmoderator/lists/v1.0/imagelistswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelistsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists")! 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()
GET
ListManagementImageLists_GetDetails
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
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/contentmoderator/lists/v1.0/imagelists/:listId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"))
.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}}/contentmoderator/lists/v1.0/imagelists/:listId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.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}}/contentmoderator/lists/v1.0/imagelists/:listId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
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}}/contentmoderator/lists/v1.0/imagelists/:listId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId',
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}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
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}}/contentmoderator/lists/v1.0/imagelists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
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}}/contentmoderator/lists/v1.0/imagelists/:listId"]
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}}/contentmoderator/lists/v1.0/imagelists/:listId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId",
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}}/contentmoderator/lists/v1.0/imagelists/:listId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId";
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}}/contentmoderator/lists/v1.0/imagelists/:listIdhttp GET {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")! 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
ListManagementImageLists_RefreshIndex
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"))
.method("POST", 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}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex');
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}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndexhttp POST {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndexwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndeximport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId/RefreshIndex")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
PUT
ListManagementImageLists_Update
{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/contentmoderator/lists/v1.0/imagelists/:listId HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"))
.header("content-type", "")
.method("PUT", 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}}/contentmoderator/lists/v1.0/imagelists/:listId")
.put(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.header("content-type", "")
.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('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
const options = {method: 'PUT', headers: {'content-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}}/contentmoderator/lists/v1.0/imagelists/:listId',
method: 'PUT',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
.put(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId',
headers: {
'content-type': ''
}
};
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: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
req.headers({
'content-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: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId';
const options = {method: 'PUT', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/lists/v1.0/imagelists/:listId" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId');
$request->setRequestMethod('PUT');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method PUT -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("PUT", "/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
headers = {"content-type": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/contentmoderator/lists/v1.0/imagelists/:listId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId \
--header 'content-type: 'http PUT {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId \
content-type:''wget --quiet \
--method PUT \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listIdimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/imagelists/:listId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
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
ListManagementTerm_AddTerm
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"))
.method("POST", 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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termhttp POST {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
DELETE
ListManagementTerm_DeleteAllTerms
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/termshttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/termswget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/termsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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()
DELETE
ListManagementTerm_DeleteTerm
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms/:term') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termhttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:termimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms/:term")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
ListManagementTerm_GetAllTerms
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
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/contentmoderator/lists/v1.0/termlists/:listId/terms HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"))
.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}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.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}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms';
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms',
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms';
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms"]
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms",
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}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/terms') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms";
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}}/contentmoderator/lists/v1.0/termlists/:listId/termshttp GET {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/termswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/termsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/terms")! 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
ListManagementTermLists_Create
{{baseUrl}}/contentmoderator/lists/v1.0/termlists
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/termlists" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/termlists HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists"))
.header("content-type", "")
.method("POST", 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}}/contentmoderator/lists/v1.0/termlists")
.post(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.header("content-type", "")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists';
const options = {method: 'POST', headers: {'content-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}}/contentmoderator/lists/v1.0/termlists',
method: 'POST',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.post(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists',
headers: {
'content-type': ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
req.headers({
'content-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}}/contentmoderator/lists/v1.0/termlists',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists';
const options = {method: 'POST', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/lists/v1.0/termlists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/lists/v1.0/termlists" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
$request->setRequestMethod('POST');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists' -Method POST -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/termlists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
headers = {"content-type": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/termlists') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists \
--header 'content-type: 'http POST {{baseUrl}}/contentmoderator/lists/v1.0/termlists \
content-type:''wget --quiet \
--method POST \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlistsimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()
DELETE
ListManagementTermLists_Delete
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/contentmoderator/lists/v1.0/termlists/:listId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"))
.method("DELETE", 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}}/contentmoderator/lists/v1.0/termlists/:listId")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.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('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId',
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: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
const options = {method: 'DELETE'};
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}}/contentmoderator/lists/v1.0/termlists/:listId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
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}}/contentmoderator/lists/v1.0/termlists/:listId" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdhttp DELETE {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
ListManagementTermLists_GetAllTermLists
{{baseUrl}}/contentmoderator/lists/v1.0/termlists
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/termlists")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
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/contentmoderator/lists/v1.0/termlists HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists"))
.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}}/contentmoderator/lists/v1.0/termlists")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.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}}/contentmoderator/lists/v1.0/termlists');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists';
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}}/contentmoderator/lists/v1.0/termlists',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists',
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}}/contentmoderator/lists/v1.0/termlists'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
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}}/contentmoderator/lists/v1.0/termlists'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists';
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}}/contentmoderator/lists/v1.0/termlists"]
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}}/contentmoderator/lists/v1.0/termlists" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists",
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}}/contentmoderator/lists/v1.0/termlists');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/termlists")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/termlists') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists";
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}}/contentmoderator/lists/v1.0/termlistshttp GET {{baseUrl}}/contentmoderator/lists/v1.0/termlistswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlistsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists")! 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()
GET
ListManagementTermLists_GetDetails
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
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/contentmoderator/lists/v1.0/termlists/:listId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"))
.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}}/contentmoderator/lists/v1.0/termlists/:listId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.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}}/contentmoderator/lists/v1.0/termlists/:listId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
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}}/contentmoderator/lists/v1.0/termlists/:listId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId',
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}}/contentmoderator/lists/v1.0/termlists/:listId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
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}}/contentmoderator/lists/v1.0/termlists/:listId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
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}}/contentmoderator/lists/v1.0/termlists/:listId"]
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}}/contentmoderator/lists/v1.0/termlists/:listId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId",
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}}/contentmoderator/lists/v1.0/termlists/:listId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId";
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}}/contentmoderator/lists/v1.0/termlists/:listIdhttp GET {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")! 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
ListManagementTermLists_RefreshIndex
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"))
.method("POST", 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}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
.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('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex');
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}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex';
const options = {method: 'POST'};
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}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndexhttp POST {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndexwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndeximport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId/RefreshIndex")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
PUT
ListManagementTermLists_Update
{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/contentmoderator/lists/v1.0/termlists/:listId HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"))
.header("content-type", "")
.method("PUT", 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}}/contentmoderator/lists/v1.0/termlists/:listId")
.put(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.header("content-type", "")
.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('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
const options = {method: 'PUT', headers: {'content-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}}/contentmoderator/lists/v1.0/termlists/:listId',
method: 'PUT',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
.put(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/lists/v1.0/termlists/:listId',
headers: {
'content-type': ''
}
};
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: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
req.headers({
'content-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: 'PUT',
url: '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId';
const options = {method: 'PUT', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/lists/v1.0/termlists/:listId" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId');
$request->setRequestMethod('PUT');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method PUT -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("PUT", "/baseUrl/contentmoderator/lists/v1.0/termlists/:listId", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
headers = {"content-type": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/contentmoderator/lists/v1.0/termlists/:listId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId \
--header 'content-type: 'http PUT {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId \
content-type:''wget --quiet \
--method PUT \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listIdimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/lists/v1.0/termlists/:listId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
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
Reviews_AddVideoFrame
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames
QUERY PARAMS
reviewId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"))
.method("POST", 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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.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('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames';
const options = {method: 'POST'};
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames';
const options = {method: 'POST'};
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frameshttp POST {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frameswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/framesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
PUT
Reviews_AddVideoTranscript
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"))
.header("content-type", "")
.method("PUT", 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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")
.put(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")
.header("content-type", "")
.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('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript';
const options = {method: 'PUT', headers: {'content-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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript',
method: 'PUT',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")
.put(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript',
headers: {
'content-type': ''
}
};
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: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript');
req.headers({
'content-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: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript';
const options = {method: 'PUT', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript');
$request->setRequestMethod('PUT');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript' -Method PUT -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("PUT", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"
headers = {"content-type": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript \
--header 'content-type: 'http PUT {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript \
content-type:''wget --quiet \
--method PUT \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcript")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
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()
PUT
Reviews_AddVideoTranscriptModerationResult
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"))
.header("content-type", "")
.method("PUT", 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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")
.put(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")
.header("content-type", "")
.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('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult';
const options = {method: 'PUT', headers: {'content-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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult',
method: 'PUT',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")
.put(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult',
headers: {
'content-type': ''
}
};
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: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult');
req.headers({
'content-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: 'PUT',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult';
const options = {method: 'PUT', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult');
$request->setRequestMethod('PUT');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult' -Method PUT -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("PUT", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"
headers = {"content-type": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult \
--header 'content-type: 'http PUT {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult \
content-type:''wget --quiet \
--method PUT \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresultimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/transcriptmoderationresult")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
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
Reviews_CreateJob
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"))
.header("content-type", "")
.method("POST", 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}}/contentmoderator/review/v1.0/teams/:teamName/jobs")
.post(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs")
.header("content-type", "")
.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('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs';
const options = {method: 'POST', headers: {'content-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}}/contentmoderator/review/v1.0/teams/:teamName/jobs',
method: 'POST',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs")
.post(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs',
headers: {
'content-type': ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs');
req.headers({
'content-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}}/contentmoderator/review/v1.0/teams/:teamName/jobs',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs';
const options = {method: 'POST', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs');
$request->setRequestMethod('POST');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs' -Method POST -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("POST", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"
headers = {"content-type": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs \
--header 'content-type: 'http POST {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs \
content-type:''wget --quiet \
--method POST \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobsimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
Reviews_CreateReviews
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews
HEADERS
UrlContentType
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "urlcontenttype: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews" {:headers {:urlcontenttype ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"
headers = HTTP::Headers{
"urlcontenttype" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"),
Headers =
{
{ "urlcontenttype", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews");
var request = new RestRequest("", Method.Post);
request.AddHeader("urlcontenttype", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("urlcontenttype", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews HTTP/1.1
Urlcontenttype:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews")
.setHeader("urlcontenttype", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"))
.header("urlcontenttype", "")
.method("POST", 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}}/contentmoderator/review/v1.0/teams/:teamName/reviews")
.post(null)
.addHeader("urlcontenttype", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews")
.header("urlcontenttype", "")
.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('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews');
xhr.setRequestHeader('urlcontenttype', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews',
headers: {urlcontenttype: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews';
const options = {method: 'POST', headers: {urlcontenttype: ''}};
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews',
method: 'POST',
headers: {
urlcontenttype: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews")
.post(null)
.addHeader("urlcontenttype", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews',
headers: {
urlcontenttype: ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews',
headers: {urlcontenttype: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews');
req.headers({
urlcontenttype: ''
});
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews',
headers: {urlcontenttype: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews';
const options = {method: 'POST', headers: {urlcontenttype: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"urlcontenttype": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews" in
let headers = Header.add (Header.init ()) "urlcontenttype" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"urlcontenttype: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews', [
'headers' => [
'urlcontenttype' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'urlcontenttype' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews');
$request->setRequestMethod('POST');
$request->setHeaders([
'urlcontenttype' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("urlcontenttype", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews' -Method POST -Headers $headers$headers=@{}
$headers.Add("urlcontenttype", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'urlcontenttype': "" }
conn.request("POST", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"
headers = {"urlcontenttype": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews"
response <- VERB("POST", url, add_headers('urlcontenttype' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["urlcontenttype"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews') do |req|
req.headers['urlcontenttype'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("urlcontenttype", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews \
--header 'urlcontenttype: 'http POST {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews \
urlcontenttype:''wget --quiet \
--method POST \
--header 'urlcontenttype: ' \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviewsimport Foundation
let headers = ["urlcontenttype": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
Reviews_GetJobDetails
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId
QUERY PARAMS
teamName
JobId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"
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/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"))
.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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
.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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId';
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId',
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId');
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId';
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"]
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId",
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId";
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}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobIdhttp GET {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/jobs/:JobId")! 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()
GET
Reviews_GetReview
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId
QUERY PARAMS
teamName
reviewId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"
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/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"))
.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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
.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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId';
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId',
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId');
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId';
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"]
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId",
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId";
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewIdhttp GET {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId")! 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()
GET
Reviews_GetVideoFrames
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
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/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"))
.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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames';
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames',
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames';
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"]
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames",
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames";
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frameshttp GET {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frameswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/framesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/frames")! 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
Reviews_PublishVideoReview
{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")require "http/client"
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"))
.method("POST", 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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
.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('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish';
const options = {method: 'POST'};
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish',
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: 'POST',
url: '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish');
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish';
const options = {method: 'POST'};
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish');
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publishhttp POST {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publishwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publishimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/review/v1.0/teams/:teamName/reviews/:reviewId/publish")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessText/Screen/ HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"))
.header("content-type", "")
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")
.post(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")
.header("content-type", "")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/';
const options = {method: 'POST', headers: {'content-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}}/contentmoderator/moderate/v1.0/ProcessText/Screen/',
method: 'POST',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")
.post(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessText/Screen/',
headers: {
'content-type': ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/');
req.headers({
'content-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}}/contentmoderator/moderate/v1.0/ProcessText/Screen/',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/';
const options = {method: 'POST', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/moderate/v1.0/ProcessText/Screen/" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/');
$request->setRequestMethod('POST');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/' -Method POST -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessText/Screen/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"
headers = {"content-type": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessText/Screen/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/ \
--header 'content-type: 'http POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/ \
content-type:''wget --quiet \
--method POST \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/import Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/Screen/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
TextModeration_DetectLanguage
{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage
HEADERS
Content-Type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage" {:headers {:content-type ""}})require "http/client"
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"
headers = HTTP::Headers{
"content-type" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("content-type", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage HTTP/1.1
Content-Type:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")
.setHeader("content-type", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"))
.header("content-type", "")
.method("POST", 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}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")
.post(null)
.addHeader("content-type", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")
.header("content-type", "")
.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('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage');
xhr.setRequestHeader('content-type', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage';
const options = {method: 'POST', headers: {'content-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}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage',
method: 'POST',
headers: {
'content-type': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")
.post(null)
.addHeader("content-type", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage',
headers: {
'content-type': ''
}
};
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: 'POST',
url: '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage',
headers: {'content-type': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage');
req.headers({
'content-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}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage',
headers: {'content-type': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage';
const options = {method: 'POST', headers: {'content-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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage" in
let headers = Header.add (Header.init ()) "content-type" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"content-type: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage', [
'headers' => [
'content-type' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage');
$request->setRequestMethod('POST');
$request->setHeaders([
'content-type' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage' -Method POST -Headers $headers$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'content-type': "" }
conn.request("POST", "/baseUrl/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"
headers = {"content-type": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage \
--header 'content-type: 'http POST {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage \
content-type:''wget --quiet \
--method POST \
--header 'content-type: ' \
--output-document \
- {{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguageimport Foundation
let headers = ["content-type": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contentmoderator/moderate/v1.0/ProcessText/DetectLanguage")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()