Flat API
GET
Get current user profile
{{baseUrl}}/me
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me")require "http/client"
url = "{{baseUrl}}/me"
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}}/me"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me"
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/me HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me"))
.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}}/me")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me")
.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}}/me');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/me'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me';
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}}/me',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me',
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}}/me'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me');
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}}/me'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me';
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}}/me"]
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}}/me" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me",
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}}/me');
echo $response->getBody();setUrl('{{baseUrl}}/me');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/me' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/me' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/me")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/me"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me")
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/me') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me";
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}}/mehttp GET {{baseUrl}}/mewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/meimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Activate the class
{{baseUrl}}/classes/:class/activate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/activate");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/activate")require "http/client"
url = "{{baseUrl}}/classes/:class/activate"
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}}/classes/:class/activate"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/activate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/activate"
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/classes/:class/activate HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/activate")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/activate"))
.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}}/classes/:class/activate")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/activate")
.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}}/classes/:class/activate');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/classes/:class/activate'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/activate';
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}}/classes/:class/activate',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/activate")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/activate',
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}}/classes/:class/activate'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/activate');
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}}/classes/:class/activate'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/activate';
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}}/classes/:class/activate"]
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}}/classes/:class/activate" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/activate",
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}}/classes/:class/activate');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/activate');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/activate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/activate' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/activate' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/classes/:class/activate")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/activate"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/activate"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/activate")
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/classes/:class/activate') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/activate";
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}}/classes/:class/activatehttp POST {{baseUrl}}/classes/:class/activatewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/classes/:class/activateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/activate")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Add a feedback comment to a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments
BODY json
{
"comment": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"comment\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments" {:content-type :json
:form-params {:comment ""}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"comment\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"),
Content = new StringContent("{\n \"comment\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"comment\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
payload := strings.NewReader("{\n \"comment\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19
{
"comment": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.setHeader("content-type", "application/json")
.setBody("{\n \"comment\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"comment\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"comment\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.header("content-type", "application/json")
.body("{\n \"comment\": \"\"\n}")
.asString(); const data = JSON.stringify({
comment: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments',
headers: {'content-type': 'application/json'},
data: {comment: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"comment":""}'
};
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "comment": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"comment\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({comment: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments',
headers: {'content-type': 'application/json'},
body: {comment: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
comment: ''
});
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments',
headers: {'content-type': 'application/json'},
data: {comment: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"comment":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"comment": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"comment\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'comment' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments', [
'body' => '{
"comment": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'comment' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'comment' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"comment": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"comment": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"comment\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
payload = { "comment": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
payload <- "{\n \"comment\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"comment\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments') do |req|
req.body = "{\n \"comment\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments";
let payload = json!({"comment": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments \
--header 'content-type: application/json' \
--data '{
"comment": ""
}'echo '{
"comment": ""
}' | \
http POST {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "comment": ""\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/commentsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["comment": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Add a user to the class
{{baseUrl}}/classes/:class/users/:user
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/users/:user");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/classes/:class/users/:user")require "http/client"
url = "{{baseUrl}}/classes/:class/users/:user"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/classes/:class/users/:user"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/users/:user");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/users/:user"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/classes/:class/users/:user HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/classes/:class/users/:user")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/users/:user"))
.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}}/classes/:class/users/:user")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/classes/:class/users/:user")
.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}}/classes/:class/users/:user');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/classes/:class/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/users/:user';
const options = {method: 'PUT'};
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}}/classes/:class/users/:user',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/users/:user")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/users/:user',
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: 'PUT', url: '{{baseUrl}}/classes/:class/users/:user'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/classes/:class/users/:user');
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}}/classes/:class/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/users/:user';
const options = {method: 'PUT'};
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}}/classes/:class/users/:user"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
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}}/classes/:class/users/:user" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/users/:user",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/classes/:class/users/:user');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/users/:user');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/users/:user');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/users/:user' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/users/:user' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/classes/:class/users/:user")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/users/:user"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/users/:user"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/users/:user")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/classes/:class/users/:user') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/users/:user";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/classes/:class/users/:userhttp PUT {{baseUrl}}/classes/:class/users/:userwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/classes/:class/users/:userimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/users/:user")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Archive the assignment
{{baseUrl}}/classes/:class/assignments/:assignment/archive
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/archive");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/assignments/:assignment/archive")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
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}}/classes/:class/assignments/:assignment/archive"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/archive");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
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/classes/:class/assignments/:assignment/archive HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/archive"))
.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}}/classes/:class/assignments/:assignment/archive")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.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}}/classes/:class/assignments/:assignment/archive');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/archive'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/archive';
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}}/classes/:class/assignments/:assignment/archive',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/archive',
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}}/classes/:class/assignments/:assignment/archive'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/archive');
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}}/classes/:class/assignments/:assignment/archive'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/archive';
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}}/classes/:class/assignments/:assignment/archive"]
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}}/classes/:class/assignments/:assignment/archive" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/archive",
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}}/classes/:class/assignments/:assignment/archive');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/archive');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/archive');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/archive' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/archive' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/classes/:class/assignments/:assignment/archive")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
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/classes/:class/assignments/:assignment/archive') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive";
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}}/classes/:class/assignments/:assignment/archivehttp POST {{baseUrl}}/classes/:class/assignments/:assignment/archivewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/archiveimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/archive")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"attachments": [
{
"score": "0000000000000000",
"type": "flat"
},
{
"type": "link",
"url": "https://flat.io/developers"
},
{
"authorName": "Flat",
"authorUrl": "https://www.youtube.com/channel/UCEUIbEP9Rba_g0r4eeGhmXw",
"description": "Discover Flat on https://flat.io",
"html": "",
"thumbnailHeight": 1052,
"thumbnailUrl": "https://i.ytimg.com/vi/SNbRUiBZ4Uw/maxresdefault.jpg",
"thumbnailWidth": 1868,
"title": "Flat - The online collaborative music notation software",
"type": "video",
"url": "https://www.youtube.com/watch?v=SNbRUiBZ4Uw"
}
],
"canvas": {
"alternateLink": "https://canvas.instructure.com/courses/00000/assignments/12345",
"id": "12345"
},
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-06-12T13:56:19.613000Z",
"creator": "5832bf149995c4024bd6de7d",
"description": "Get started with Flat",
"dueDate": "2017-07-12T13:56:19.613000Z",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/detail",
"id": "1235665432"
},
"lti": {
"id": "12345"
},
"maxPoints": 100,
"scheduledDate": "2017-06-18T13:56:19.613000Z",
"state": "active",
"submissions": [
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-03-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"id": "58c4955c226ffff257211a90",
"submissionDate": "2017-03-12T00:25:22.748000Z"
}
],
"title": "My first assignment"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Archive the class
{{baseUrl}}/classes/:class/archive
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/archive");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/archive")require "http/client"
url = "{{baseUrl}}/classes/:class/archive"
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}}/classes/:class/archive"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/archive");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/archive"
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/classes/:class/archive HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/archive")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/archive"))
.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}}/classes/:class/archive")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/archive")
.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}}/classes/:class/archive');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/classes/:class/archive'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/archive';
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}}/classes/:class/archive',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/archive")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/archive',
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}}/classes/:class/archive'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/archive');
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}}/classes/:class/archive'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/archive';
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}}/classes/:class/archive"]
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}}/classes/:class/archive" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/archive",
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}}/classes/:class/archive');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/archive');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/archive');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/archive' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/archive' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/classes/:class/archive")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/archive"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/archive"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/archive")
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/classes/:class/archive') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/archive";
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}}/classes/:class/archivehttp POST {{baseUrl}}/classes/:class/archivewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/classes/:class/archiveimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/archive")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Assignment creation
{{baseUrl}}/classes/:class/assignments
BODY json
{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/assignments" {:content-type :json
:form-params {:assignedStudents []
:assigneeMode ""
:attachments [{:googleDriveFileId ""
:lockScoreTemplate false
:score ""
:sharingMode ""
:type ""
:url ""
:worksheet ""}]
:cover ""
:coverFile ""
:description ""
:dueDate ""
:googleClassroom {:topicId ""}
:maxPoints ""
:microsoftGraph {:categories []}
:nbPlaybackAuthorized ""
:scheduledDate ""
:state ""
:title ""
:toolset ""
:type ""}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments"),
Content = new StringContent("{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments"
payload := strings.NewReader("{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/classes/:class/assignments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 551
{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/assignments")
.setHeader("content-type", "application/json")
.setBody("{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/assignments")
.header("content-type", "application/json")
.body("{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}")
.asString(); const data = JSON.stringify({
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {
topicId: ''
},
maxPoints: '',
microsoftGraph: {
categories: []
},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
type: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/classes/:class/assignments');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments',
headers: {'content-type': 'application/json'},
data: {
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {topicId: ''},
maxPoints: '',
microsoftGraph: {categories: []},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
type: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"assignedStudents":[],"assigneeMode":"","attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"cover":"","coverFile":"","description":"","dueDate":"","googleClassroom":{"topicId":""},"maxPoints":"","microsoftGraph":{"categories":[]},"nbPlaybackAuthorized":"","scheduledDate":"","state":"","title":"","toolset":"","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}}/classes/:class/assignments',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "assignedStudents": [],\n "assigneeMode": "",\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "cover": "",\n "coverFile": "",\n "description": "",\n "dueDate": "",\n "googleClassroom": {\n "topicId": ""\n },\n "maxPoints": "",\n "microsoftGraph": {\n "categories": []\n },\n "nbPlaybackAuthorized": "",\n "scheduledDate": "",\n "state": "",\n "title": "",\n "toolset": "",\n "type": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {topicId: ''},
maxPoints: '',
microsoftGraph: {categories: []},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
type: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments',
headers: {'content-type': 'application/json'},
body: {
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {topicId: ''},
maxPoints: '',
microsoftGraph: {categories: []},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
type: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/assignments');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {
topicId: ''
},
maxPoints: '',
microsoftGraph: {
categories: []
},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
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}}/classes/:class/assignments',
headers: {'content-type': 'application/json'},
data: {
assignedStudents: [],
assigneeMode: '',
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
cover: '',
coverFile: '',
description: '',
dueDate: '',
googleClassroom: {topicId: ''},
maxPoints: '',
microsoftGraph: {categories: []},
nbPlaybackAuthorized: '',
scheduledDate: '',
state: '',
title: '',
toolset: '',
type: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"assignedStudents":[],"assigneeMode":"","attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"cover":"","coverFile":"","description":"","dueDate":"","googleClassroom":{"topicId":""},"maxPoints":"","microsoftGraph":{"categories":[]},"nbPlaybackAuthorized":"","scheduledDate":"","state":"","title":"","toolset":"","type":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assignedStudents": @[ ],
@"assigneeMode": @"",
@"attachments": @[ @{ @"googleDriveFileId": @"", @"lockScoreTemplate": @NO, @"score": @"", @"sharingMode": @"", @"type": @"", @"url": @"", @"worksheet": @"" } ],
@"cover": @"",
@"coverFile": @"",
@"description": @"",
@"dueDate": @"",
@"googleClassroom": @{ @"topicId": @"" },
@"maxPoints": @"",
@"microsoftGraph": @{ @"categories": @[ ] },
@"nbPlaybackAuthorized": @"",
@"scheduledDate": @"",
@"state": @"",
@"title": @"",
@"toolset": @"",
@"type": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'assignedStudents' => [
],
'assigneeMode' => '',
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'cover' => '',
'coverFile' => '',
'description' => '',
'dueDate' => '',
'googleClassroom' => [
'topicId' => ''
],
'maxPoints' => '',
'microsoftGraph' => [
'categories' => [
]
],
'nbPlaybackAuthorized' => '',
'scheduledDate' => '',
'state' => '',
'title' => '',
'toolset' => '',
'type' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/classes/:class/assignments', [
'body' => '{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'assignedStudents' => [
],
'assigneeMode' => '',
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'cover' => '',
'coverFile' => '',
'description' => '',
'dueDate' => '',
'googleClassroom' => [
'topicId' => ''
],
'maxPoints' => '',
'microsoftGraph' => [
'categories' => [
]
],
'nbPlaybackAuthorized' => '',
'scheduledDate' => '',
'state' => '',
'title' => '',
'toolset' => '',
'type' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'assignedStudents' => [
],
'assigneeMode' => '',
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'cover' => '',
'coverFile' => '',
'description' => '',
'dueDate' => '',
'googleClassroom' => [
'topicId' => ''
],
'maxPoints' => '',
'microsoftGraph' => [
'categories' => [
]
],
'nbPlaybackAuthorized' => '',
'scheduledDate' => '',
'state' => '',
'title' => '',
'toolset' => '',
'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/classes/:class/assignments", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments"
payload = {
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": False,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": { "topicId": "" },
"maxPoints": "",
"microsoftGraph": { "categories": [] },
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments"
payload <- "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/classes/:class/assignments') do |req|
req.body = "{\n \"assignedStudents\": [],\n \"assigneeMode\": \"\",\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"cover\": \"\",\n \"coverFile\": \"\",\n \"description\": \"\",\n \"dueDate\": \"\",\n \"googleClassroom\": {\n \"topicId\": \"\"\n },\n \"maxPoints\": \"\",\n \"microsoftGraph\": {\n \"categories\": []\n },\n \"nbPlaybackAuthorized\": \"\",\n \"scheduledDate\": \"\",\n \"state\": \"\",\n \"title\": \"\",\n \"toolset\": \"\",\n \"type\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments";
let payload = json!({
"assignedStudents": (),
"assigneeMode": "",
"attachments": (
json!({
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
})
),
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": json!({"topicId": ""}),
"maxPoints": "",
"microsoftGraph": json!({"categories": ()}),
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/classes/:class/assignments \
--header 'content-type: application/json' \
--data '{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}'echo '{
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": {
"topicId": ""
},
"maxPoints": "",
"microsoftGraph": {
"categories": []
},
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
}' | \
http POST {{baseUrl}}/classes/:class/assignments \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "assignedStudents": [],\n "assigneeMode": "",\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "cover": "",\n "coverFile": "",\n "description": "",\n "dueDate": "",\n "googleClassroom": {\n "topicId": ""\n },\n "maxPoints": "",\n "microsoftGraph": {\n "categories": []\n },\n "nbPlaybackAuthorized": "",\n "scheduledDate": "",\n "state": "",\n "title": "",\n "toolset": "",\n "type": ""\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignmentsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"assignedStudents": [],
"assigneeMode": "",
"attachments": [
[
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
]
],
"cover": "",
"coverFile": "",
"description": "",
"dueDate": "",
"googleClassroom": ["topicId": ""],
"maxPoints": "",
"microsoftGraph": ["categories": []],
"nbPlaybackAuthorized": "",
"scheduledDate": "",
"state": "",
"title": "",
"toolset": "",
"type": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"attachments": [
{
"score": "0000000000000000",
"type": "flat"
},
{
"type": "link",
"url": "https://flat.io/developers"
},
{
"authorName": "Flat",
"authorUrl": "https://www.youtube.com/channel/UCEUIbEP9Rba_g0r4eeGhmXw",
"description": "Discover Flat on https://flat.io",
"html": "",
"thumbnailHeight": 1052,
"thumbnailUrl": "https://i.ytimg.com/vi/SNbRUiBZ4Uw/maxresdefault.jpg",
"thumbnailWidth": 1868,
"title": "Flat - The online collaborative music notation software",
"type": "video",
"url": "https://www.youtube.com/watch?v=SNbRUiBZ4Uw"
}
],
"canvas": {
"alternateLink": "https://canvas.instructure.com/courses/00000/assignments/12345",
"id": "12345"
},
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-06-12T13:56:19.613000Z",
"creator": "5832bf149995c4024bd6de7d",
"description": "Get started with Flat",
"dueDate": "2017-07-12T13:56:19.613000Z",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/detail",
"id": "1235665432"
},
"lti": {
"id": "12345"
},
"maxPoints": 100,
"scheduledDate": "2017-06-18T13:56:19.613000Z",
"state": "active",
"submissions": [
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-03-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"id": "58c4955c226ffff257211a90",
"submissionDate": "2017-03-12T00:25:22.748000Z"
}
],
"title": "My first assignment"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Assignments listing
{{baseUrl}}/classes/:class/assignments
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments"
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}}/classes/:class/assignments"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments"
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/classes/:class/assignments HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments"))
.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}}/classes/:class/assignments")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments")
.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}}/classes/:class/assignments');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/classes/:class/assignments'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments';
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}}/classes/:class/assignments',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments',
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}}/classes/:class/assignments'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments');
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}}/classes/:class/assignments'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments';
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}}/classes/:class/assignments"]
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}}/classes/:class/assignments" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments",
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}}/classes/:class/assignments');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments")
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/classes/:class/assignments') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments";
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}}/classes/:class/assignmentshttp GET {{baseUrl}}/classes/:class/assignmentswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignmentsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"attachments": [
{
"score": "0000000000000000",
"type": "flat"
},
{
"type": "link",
"url": "https://flat.io/developers"
},
{
"authorName": "Flat",
"authorUrl": "https://www.youtube.com/channel/UCEUIbEP9Rba_g0r4eeGhmXw",
"description": "Discover Flat on https://flat.io",
"html": "",
"thumbnailHeight": 1052,
"thumbnailUrl": "https://i.ytimg.com/vi/SNbRUiBZ4Uw/maxresdefault.jpg",
"thumbnailWidth": 1868,
"title": "Flat - The online collaborative music notation software",
"type": "video",
"url": "https://www.youtube.com/watch?v=SNbRUiBZ4Uw"
}
],
"canvas": {
"alternateLink": "https://canvas.instructure.com/courses/00000/assignments/12345",
"id": "12345"
},
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-06-12T13:56:19.613000Z",
"creator": "5832bf149995c4024bd6de7d",
"description": "Get started with Flat",
"dueDate": "2017-07-12T13:56:19.613000Z",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/detail",
"id": "1235665432"
},
"lti": {
"id": "12345"
},
"maxPoints": 100,
"scheduledDate": "2017-06-18T13:56:19.613000Z",
"state": "active",
"submissions": [
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-03-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"id": "58c4955c226ffff257211a90",
"submissionDate": "2017-03-12T00:25:22.748000Z"
}
],
"title": "My first assignment"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
CSV Grades exports
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv"
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}}/classes/:class/assignments/:assignment/submissions/csv"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv"
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/classes/:class/assignments/:assignment/submissions/csv HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv"))
.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}}/classes/:class/assignments/:assignment/submissions/csv")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")
.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}}/classes/:class/assignments/:assignment/submissions/csv');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv';
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}}/classes/:class/assignments/:assignment/submissions/csv',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/csv',
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}}/classes/:class/assignments/:assignment/submissions/csv'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv');
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}}/classes/:class/assignments/:assignment/submissions/csv'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv';
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}}/classes/:class/assignments/:assignment/submissions/csv"]
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}}/classes/:class/assignments/:assignment/submissions/csv" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv",
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}}/classes/:class/assignments/:assignment/submissions/csv');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions/csv")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")
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/classes/:class/assignments/:assignment/submissions/csv') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv";
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}}/classes/:class/assignments/:assignment/submissions/csvhttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissions/csvwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/csvimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/csv")! 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()RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Copy an assignment
{{baseUrl}}/classes/:class/assignments/:assignment/copy
BODY json
{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/copy");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/:class/assignments/:assignment/copy" {:content-type :json
:form-params {:assignment ""
:classroom ""
:scheduledDate ""}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/copy"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments/:assignment/copy"),
Content = new StringContent("{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/copy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/copy"
payload := strings.NewReader("{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/classes/:class/assignments/:assignment/copy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64
{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/:class/assignments/:assignment/copy")
.setHeader("content-type", "application/json")
.setBody("{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/copy"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/copy")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/:class/assignments/:assignment/copy")
.header("content-type", "application/json")
.body("{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}")
.asString(); const data = JSON.stringify({
assignment: '',
classroom: '',
scheduledDate: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/copy');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/copy',
headers: {'content-type': 'application/json'},
data: {assignment: '', classroom: '', scheduledDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/copy';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"assignment":"","classroom":"","scheduledDate":""}'
};
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}}/classes/:class/assignments/:assignment/copy',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "assignment": "",\n "classroom": "",\n "scheduledDate": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/copy")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/copy',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({assignment: '', classroom: '', scheduledDate: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/copy',
headers: {'content-type': 'application/json'},
body: {assignment: '', classroom: '', scheduledDate: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/copy');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
assignment: '',
classroom: '',
scheduledDate: ''
});
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}}/classes/:class/assignments/:assignment/copy',
headers: {'content-type': 'application/json'},
data: {assignment: '', classroom: '', scheduledDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/copy';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"assignment":"","classroom":"","scheduledDate":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assignment": @"",
@"classroom": @"",
@"scheduledDate": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments/:assignment/copy"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments/:assignment/copy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/copy",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'assignment' => '',
'classroom' => '',
'scheduledDate' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/classes/:class/assignments/:assignment/copy', [
'body' => '{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/copy');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'assignment' => '',
'classroom' => '',
'scheduledDate' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'assignment' => '',
'classroom' => '',
'scheduledDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/copy');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/classes/:class/assignments/:assignment/copy", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/copy"
payload = {
"assignment": "",
"classroom": "",
"scheduledDate": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/copy"
payload <- "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/copy")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/classes/:class/assignments/:assignment/copy') do |req|
req.body = "{\n \"assignment\": \"\",\n \"classroom\": \"\",\n \"scheduledDate\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/copy";
let payload = json!({
"assignment": "",
"classroom": "",
"scheduledDate": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/classes/:class/assignments/:assignment/copy \
--header 'content-type: application/json' \
--data '{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}'echo '{
"assignment": "",
"classroom": "",
"scheduledDate": ""
}' | \
http POST {{baseUrl}}/classes/:class/assignments/:assignment/copy \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "assignment": "",\n "classroom": "",\n "scheduledDate": ""\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/copyimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"assignment": "",
"classroom": "",
"scheduledDate": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/copy")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"attachments": [
{
"score": "0000000000000000",
"type": "flat"
},
{
"type": "link",
"url": "https://flat.io/developers"
},
{
"authorName": "Flat",
"authorUrl": "https://www.youtube.com/channel/UCEUIbEP9Rba_g0r4eeGhmXw",
"description": "Discover Flat on https://flat.io",
"html": "",
"thumbnailHeight": 1052,
"thumbnailUrl": "https://i.ytimg.com/vi/SNbRUiBZ4Uw/maxresdefault.jpg",
"thumbnailWidth": 1868,
"title": "Flat - The online collaborative music notation software",
"type": "video",
"url": "https://www.youtube.com/watch?v=SNbRUiBZ4Uw"
}
],
"canvas": {
"alternateLink": "https://canvas.instructure.com/courses/00000/assignments/12345",
"id": "12345"
},
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-06-12T13:56:19.613000Z",
"creator": "5832bf149995c4024bd6de7d",
"description": "Get started with Flat",
"dueDate": "2017-07-12T13:56:19.613000Z",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/detail",
"id": "1235665432"
},
"lti": {
"id": "12345"
},
"maxPoints": 100,
"scheduledDate": "2017-06-18T13:56:19.613000Z",
"state": "active",
"submissions": [
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-03-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"id": "58c4955c226ffff257211a90",
"submissionDate": "2017-03-12T00:25:22.748000Z"
}
],
"title": "My first assignment"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new class
{{baseUrl}}/classes
BODY json
{
"name": "",
"section": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"name\": \"\",\n \"section\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes" {:content-type :json
:form-params {:name ""
:section ""}})require "http/client"
url = "{{baseUrl}}/classes"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/classes"),
Content = new StringContent("{\n \"name\": \"\",\n \"section\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"name\": \"\",\n \"section\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes"
payload := strings.NewReader("{\n \"name\": \"\",\n \"section\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/classes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33
{
"name": "",
"section": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes")
.setHeader("content-type", "application/json")
.setBody("{\n \"name\": \"\",\n \"section\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"name\": \"\",\n \"section\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"name\": \"\",\n \"section\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes")
.header("content-type", "application/json")
.body("{\n \"name\": \"\",\n \"section\": \"\"\n}")
.asString(); const data = JSON.stringify({
name: '',
section: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/classes');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes',
headers: {'content-type': 'application/json'},
data: {name: '', section: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"name":"","section":""}'
};
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}}/classes',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "name": "",\n "section": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"name\": \"\",\n \"section\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({name: '', section: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/classes',
headers: {'content-type': 'application/json'},
body: {name: '', section: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
name: '',
section: ''
});
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}}/classes',
headers: {'content-type': 'application/json'},
data: {name: '', section: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"name":"","section":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
@"section": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"name\": \"\",\n \"section\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'name' => '',
'section' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/classes', [
'body' => '{
"name": "",
"section": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'name' => '',
'section' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'name' => '',
'section' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"name": "",
"section": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"name": "",
"section": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/classes", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes"
payload = {
"name": "",
"section": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes"
payload <- "{\n \"name\": \"\",\n \"section\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/classes') do |req|
req.body = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes";
let payload = json!({
"name": "",
"section": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/classes \
--header 'content-type: application/json' \
--data '{
"name": "",
"section": ""
}'echo '{
"name": "",
"section": ""
}' | \
http POST {{baseUrl}}/classes \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "name": "",\n "section": ""\n}' \
--output-document \
- {{baseUrl}}/classesimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"name": "",
"section": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Create or edit a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions
BODY json
{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/classes/:class/assignments/:assignment/submissions" {:content-type :json
:form-params {:attachments [{:googleDriveFileId ""
:lockScoreTemplate false
:score ""
:sharingMode ""
:type ""
:url ""
:worksheet ""}]
:comments {:total ""
:unread ""}
:draftGrade ""
:grade ""
:return false
:submit false}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments/:assignment/submissions"),
Content = new StringContent("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
payload := strings.NewReader("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/classes/:class/assignments/:assignment/submissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 332
{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.setHeader("content-type", "application/json")
.setBody("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.header("content-type", "application/json")
.body("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
.asString(); const data = JSON.stringify({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {
total: '',
unread: ''
},
draftGrade: '',
grade: '',
return: false,
submit: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions',
headers: {'content-type': 'application/json'},
data: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"comments":{"total":"","unread":""},"draftGrade":"","grade":"","return":false,"submit":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "comments": {\n "total": "",\n "unread": ""\n },\n "draftGrade": "",\n "grade": "",\n "return": false,\n "submit": false\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions',
headers: {'content-type': 'application/json'},
body: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {
total: '',
unread: ''
},
draftGrade: '',
grade: '',
return: false,
submit: false
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions',
headers: {'content-type': 'application/json'},
data: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"comments":{"total":"","unread":""},"draftGrade":"","grade":"","return":false,"submit":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attachments": @[ @{ @"googleDriveFileId": @"", @"lockScoreTemplate": @NO, @"score": @"", @"sharingMode": @"", @"type": @"", @"url": @"", @"worksheet": @"" } ],
@"comments": @{ @"total": @"", @"unread": @"" },
@"draftGrade": @"",
@"grade": @"",
@"return": @NO,
@"submit": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments/:assignment/submissions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments/:assignment/submissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions', [
'body' => '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/classes/:class/assignments/:assignment/submissions", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
payload = {
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": False,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": False,
"submit": False
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
payload <- "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/classes/:class/assignments/:assignment/submissions') do |req|
req.body = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions";
let payload = json!({
"attachments": (
json!({
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
})
),
"comments": json!({
"total": "",
"unread": ""
}),
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/classes/:class/assignments/:assignment/submissions \
--header 'content-type: application/json' \
--data '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'echo '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}' | \
http PUT {{baseUrl}}/classes/:class/assignments/:assignment/submissions \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "comments": {\n "total": "",\n "unread": ""\n },\n "draftGrade": "",\n "grade": "",\n "return": false,\n "submit": false\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissionsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"attachments": [
[
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
]
],
"comments": [
"total": "",
"unread": ""
],
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a feedback comment to a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
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/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"))
.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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment';
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment';
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"]
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment",
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
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/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment";
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:commenthttp DELETE {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:commentwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:commentimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission
QUERY PARAMS
class
assignment
submission
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
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}}/classes/:class/assignments/:assignment/submissions/:submission"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
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/classes/:class/assignments/:assignment/submissions/:submission HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"))
.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}}/classes/:class/assignments/:assignment/submissions/:submission")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.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}}/classes/:class/assignments/:assignment/submissions/:submission');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
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}}/classes/:class/assignments/:assignment/submissions/:submission',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission',
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}}/classes/:class/assignments/:assignment/submissions/:submission'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
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}}/classes/:class/assignments/:assignment/submissions/:submission'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
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}}/classes/:class/assignments/:assignment/submissions/:submission"]
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}}/classes/:class/assignments/:assignment/submissions/:submission" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission",
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}}/classes/:class/assignments/:assignment/submissions/:submission');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
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/classes/:class/assignments/:assignment/submissions/:submission') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission";
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}}/classes/:class/assignments/:assignment/submissions/:submissionhttp DELETE {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submissionwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submissionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Edit a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission
BODY json
{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission" {:content-type :json
:form-params {:attachments [{:googleDriveFileId ""
:lockScoreTemplate false
:score ""
:sharingMode ""
:type ""
:url ""
:worksheet ""}]
:comments {:total ""
:unread ""}
:draftGrade ""
:grade ""
:return false
:submit false}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"),
Content = new StringContent("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
payload := strings.NewReader("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/classes/:class/assignments/:assignment/submissions/:submission HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 332
{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.setHeader("content-type", "application/json")
.setBody("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.header("content-type", "application/json")
.body("{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
.asString(); const data = JSON.stringify({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {
total: '',
unread: ''
},
draftGrade: '',
grade: '',
return: false,
submit: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission',
headers: {'content-type': 'application/json'},
data: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"comments":{"total":"","unread":""},"draftGrade":"","grade":"","return":false,"submit":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "comments": {\n "total": "",\n "unread": ""\n },\n "draftGrade": "",\n "grade": "",\n "return": false,\n "submit": false\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission',
headers: {'content-type': 'application/json'},
body: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {
total: '',
unread: ''
},
draftGrade: '',
grade: '',
return: false,
submit: false
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission',
headers: {'content-type': 'application/json'},
data: {
attachments: [
{
googleDriveFileId: '',
lockScoreTemplate: false,
score: '',
sharingMode: '',
type: '',
url: '',
worksheet: ''
}
],
comments: {total: '', unread: ''},
draftGrade: '',
grade: '',
return: false,
submit: false
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"attachments":[{"googleDriveFileId":"","lockScoreTemplate":false,"score":"","sharingMode":"","type":"","url":"","worksheet":""}],"comments":{"total":"","unread":""},"draftGrade":"","grade":"","return":false,"submit":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attachments": @[ @{ @"googleDriveFileId": @"", @"lockScoreTemplate": @NO, @"score": @"", @"sharingMode": @"", @"type": @"", @"url": @"", @"worksheet": @"" } ],
@"comments": @{ @"total": @"", @"unread": @"" },
@"draftGrade": @"",
@"grade": @"",
@"return": @NO,
@"submit": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission', [
'body' => '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'attachments' => [
[
'googleDriveFileId' => '',
'lockScoreTemplate' => null,
'score' => '',
'sharingMode' => '',
'type' => '',
'url' => '',
'worksheet' => ''
]
],
'comments' => [
'total' => '',
'unread' => ''
],
'draftGrade' => '',
'grade' => '',
'return' => null,
'submit' => null
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
payload = {
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": False,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": False,
"submit": False
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
payload <- "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/classes/:class/assignments/:assignment/submissions/:submission') do |req|
req.body = "{\n \"attachments\": [\n {\n \"googleDriveFileId\": \"\",\n \"lockScoreTemplate\": false,\n \"score\": \"\",\n \"sharingMode\": \"\",\n \"type\": \"\",\n \"url\": \"\",\n \"worksheet\": \"\"\n }\n ],\n \"comments\": {\n \"total\": \"\",\n \"unread\": \"\"\n },\n \"draftGrade\": \"\",\n \"grade\": \"\",\n \"return\": false,\n \"submit\": false\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission";
let payload = json!({
"attachments": (
json!({
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
})
),
"comments": json!({
"total": "",
"unread": ""
}),
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission \
--header 'content-type: application/json' \
--data '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}'echo '{
"attachments": [
{
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
}
],
"comments": {
"total": "",
"unread": ""
},
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
}' | \
http PUT {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "attachments": [\n {\n "googleDriveFileId": "",\n "lockScoreTemplate": false,\n "score": "",\n "sharingMode": "",\n "type": "",\n "url": "",\n "worksheet": ""\n }\n ],\n "comments": {\n "total": "",\n "unread": ""\n },\n "draftGrade": "",\n "grade": "",\n "return": false,\n "submit": false\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submissionimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"attachments": [
[
"googleDriveFileId": "",
"lockScoreTemplate": false,
"score": "",
"sharingMode": "",
"type": "",
"url": "",
"worksheet": ""
]
],
"comments": [
"total": "",
"unread": ""
],
"draftGrade": "",
"grade": "",
"return": false,
"submit": false
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Excel Grades exports
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel"
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}}/classes/:class/assignments/:assignment/submissions/excel"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel"
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/classes/:class/assignments/:assignment/submissions/excel HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel"))
.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}}/classes/:class/assignments/:assignment/submissions/excel")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")
.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}}/classes/:class/assignments/:assignment/submissions/excel');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel';
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}}/classes/:class/assignments/:assignment/submissions/excel',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/excel',
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}}/classes/:class/assignments/:assignment/submissions/excel'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel');
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}}/classes/:class/assignments/:assignment/submissions/excel'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel';
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}}/classes/:class/assignments/:assignment/submissions/excel"]
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}}/classes/:class/assignments/:assignment/submissions/excel" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel",
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}}/classes/:class/assignments/:assignment/submissions/excel');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions/excel")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")
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/classes/:class/assignments/:assignment/submissions/excel') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel";
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}}/classes/:class/assignments/:assignment/submissions/excelhttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissions/excelwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/excelimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/excel")! 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()RESPONSE HEADERS
Content-Type
application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
RESPONSE BODY text
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a student submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
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}}/classes/:class/assignments/:assignment/submissions/:submission"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
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/classes/:class/assignments/:assignment/submissions/:submission HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"))
.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}}/classes/:class/assignments/:assignment/submissions/:submission")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.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}}/classes/:class/assignments/:assignment/submissions/:submission');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
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}}/classes/:class/assignments/:assignment/submissions/:submission',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission',
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}}/classes/:class/assignments/:assignment/submissions/:submission'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
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}}/classes/:class/assignments/:assignment/submissions/:submission'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission';
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}}/classes/:class/assignments/:assignment/submissions/:submission"]
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}}/classes/:class/assignments/:assignment/submissions/:submission" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission",
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}}/classes/:class/assignments/:assignment/submissions/:submission');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")
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/classes/:class/assignments/:assignment/submissions/:submission') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission";
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}}/classes/:class/assignments/:assignment/submissions/:submissionhttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submissionwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submissionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get the details of a single class
{{baseUrl}}/classes/:class
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class")require "http/client"
url = "{{baseUrl}}/classes/:class"
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}}/classes/:class"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class"
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/classes/:class HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class"))
.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}}/classes/:class")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class")
.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}}/classes/:class');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/classes/:class'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class';
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}}/classes/:class',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class',
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}}/classes/:class'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class');
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}}/classes/:class'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class';
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}}/classes/:class"]
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}}/classes/:class" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class",
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}}/classes/:class');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class")
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/classes/:class') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class";
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}}/classes/:classhttp GET {{baseUrl}}/classes/:classwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:classimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get the history of the submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history"
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}}/classes/:class/assignments/:assignment/submissions/:submission/history"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history"
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/classes/:class/assignments/:assignment/submissions/:submission/history HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history"))
.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}}/classes/:class/assignments/:assignment/submissions/:submission/history")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")
.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}}/classes/:class/assignments/:assignment/submissions/:submission/history');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history';
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}}/classes/:class/assignments/:assignment/submissions/:submission/history',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/history',
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}}/classes/:class/assignments/:assignment/submissions/:submission/history'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history');
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}}/classes/:class/assignments/:assignment/submissions/:submission/history'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history';
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}}/classes/:class/assignments/:assignment/submissions/:submission/history"]
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}}/classes/:class/assignments/:assignment/submissions/:submission/history" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history",
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}}/classes/:class/assignments/:assignment/submissions/:submission/history');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/history")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")
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/classes/:class/assignments/:assignment/submissions/:submission/history') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history";
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}}/classes/:class/assignments/:assignment/submissions/:submission/historyhttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/historywget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/historyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/history")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Join a class
{{baseUrl}}/classes/enroll/:enrollmentCode
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/enroll/:enrollmentCode");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/classes/enroll/:enrollmentCode")require "http/client"
url = "{{baseUrl}}/classes/enroll/:enrollmentCode"
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}}/classes/enroll/:enrollmentCode"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/enroll/:enrollmentCode");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/enroll/:enrollmentCode"
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/classes/enroll/:enrollmentCode HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/classes/enroll/:enrollmentCode")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/enroll/:enrollmentCode"))
.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}}/classes/enroll/:enrollmentCode")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/classes/enroll/:enrollmentCode")
.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}}/classes/enroll/:enrollmentCode');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/classes/enroll/:enrollmentCode'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/enroll/:enrollmentCode';
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}}/classes/enroll/:enrollmentCode',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/enroll/:enrollmentCode")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/enroll/:enrollmentCode',
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}}/classes/enroll/:enrollmentCode'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/classes/enroll/:enrollmentCode');
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}}/classes/enroll/:enrollmentCode'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/enroll/:enrollmentCode';
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}}/classes/enroll/:enrollmentCode"]
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}}/classes/enroll/:enrollmentCode" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/enroll/:enrollmentCode",
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}}/classes/enroll/:enrollmentCode');
echo $response->getBody();setUrl('{{baseUrl}}/classes/enroll/:enrollmentCode');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/enroll/:enrollmentCode');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/enroll/:enrollmentCode' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/enroll/:enrollmentCode' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/classes/enroll/:enrollmentCode")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/enroll/:enrollmentCode"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/enroll/:enrollmentCode"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/enroll/:enrollmentCode")
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/classes/enroll/:enrollmentCode') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/enroll/:enrollmentCode";
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}}/classes/enroll/:enrollmentCodehttp POST {{baseUrl}}/classes/enroll/:enrollmentCodewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/classes/enroll/:enrollmentCodeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/enroll/:enrollmentCode")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the classes available for the current user
{{baseUrl}}/classes
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes")require "http/client"
url = "{{baseUrl}}/classes"
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}}/classes"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes"
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/classes HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes"))
.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}}/classes")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes")
.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}}/classes');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/classes'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes';
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}}/classes',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes',
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}}/classes'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes');
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}}/classes'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes';
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}}/classes"]
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}}/classes" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes",
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}}/classes');
echo $response->getBody();setUrl('{{baseUrl}}/classes');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes")
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/classes') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes";
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}}/classeshttp GET {{baseUrl}}/classeswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the feedback comments of a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
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/classes/:class/assignments/:assignment/submissions/:submission/comments HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"))
.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}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.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}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments';
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments',
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments';
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments"]
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments",
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")
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/classes/:class/assignments/:assignment/submissions/:submission/comments') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments";
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}}/classes/:class/assignments/:assignment/submissions/:submission/commentshttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/commentswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/commentsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the students' submissions
{{baseUrl}}/classes/:class/assignments/:assignment/submissions
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/assignments/:assignment/submissions")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
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}}/classes/:class/assignments/:assignment/submissions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
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/classes/:class/assignments/:assignment/submissions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions"))
.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}}/classes/:class/assignments/:assignment/submissions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.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}}/classes/:class/assignments/:assignment/submissions');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions';
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}}/classes/:class/assignments/:assignment/submissions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions',
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}}/classes/:class/assignments/:assignment/submissions'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
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}}/classes/:class/assignments/:assignment/submissions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions';
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}}/classes/:class/assignments/:assignment/submissions"]
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}}/classes/:class/assignments/:assignment/submissions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions",
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}}/classes/:class/assignments/:assignment/submissions');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/assignments/:assignment/submissions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions")
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/classes/:class/assignments/:assignment/submissions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions";
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}}/classes/:class/assignments/:assignment/submissionshttp GET {{baseUrl}}/classes/:class/assignments/:assignment/submissionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the submissions for a student
{{baseUrl}}/classes/:class/students/:user/submissions
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/students/:user/submissions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/classes/:class/students/:user/submissions")require "http/client"
url = "{{baseUrl}}/classes/:class/students/:user/submissions"
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}}/classes/:class/students/:user/submissions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/students/:user/submissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/students/:user/submissions"
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/classes/:class/students/:user/submissions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/classes/:class/students/:user/submissions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/students/:user/submissions"))
.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}}/classes/:class/students/:user/submissions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/classes/:class/students/:user/submissions")
.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}}/classes/:class/students/:user/submissions');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/classes/:class/students/:user/submissions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/students/:user/submissions';
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}}/classes/:class/students/:user/submissions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/students/:user/submissions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/students/:user/submissions',
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}}/classes/:class/students/:user/submissions'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/classes/:class/students/:user/submissions');
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}}/classes/:class/students/:user/submissions'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/students/:user/submissions';
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}}/classes/:class/students/:user/submissions"]
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}}/classes/:class/students/:user/submissions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/students/:user/submissions",
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}}/classes/:class/students/:user/submissions');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/students/:user/submissions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/students/:user/submissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/students/:user/submissions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/students/:user/submissions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/classes/:class/students/:user/submissions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/students/:user/submissions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/students/:user/submissions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/students/:user/submissions")
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/classes/:class/students/:user/submissions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/students/:user/submissions";
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}}/classes/:class/students/:user/submissionshttp GET {{baseUrl}}/classes/:class/students/:user/submissionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/classes/:class/students/:user/submissionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/students/:user/submissions")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Remove a user from the class
{{baseUrl}}/classes/:class/users/:user
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/users/:user");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/classes/:class/users/:user")require "http/client"
url = "{{baseUrl}}/classes/:class/users/:user"
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}}/classes/:class/users/:user"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/users/:user");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/users/:user"
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/classes/:class/users/:user HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/classes/:class/users/:user")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/users/:user"))
.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}}/classes/:class/users/:user")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/classes/:class/users/:user")
.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}}/classes/:class/users/:user');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/classes/:class/users/:user'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/users/:user';
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}}/classes/:class/users/:user',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/users/:user")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/users/:user',
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}}/classes/:class/users/:user'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/classes/:class/users/:user');
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}}/classes/:class/users/:user'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/users/:user';
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}}/classes/:class/users/:user"]
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}}/classes/:class/users/:user" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/users/:user",
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}}/classes/:class/users/:user');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/users/:user');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/users/:user');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/users/:user' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/users/:user' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/classes/:class/users/:user")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/users/:user"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/users/:user"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/users/:user")
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/classes/:class/users/:user') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/users/:user";
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}}/classes/:class/users/:userhttp DELETE {{baseUrl}}/classes/:class/users/:userwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/classes/:class/users/:userimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/users/:user")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Unarchive the assignment.
{{baseUrl}}/classes/:class/assignments/:assignment/archive
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/archive");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/classes/:class/assignments/:assignment/archive")require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
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}}/classes/:class/assignments/:assignment/archive"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/archive");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
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/classes/:class/assignments/:assignment/archive HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/archive"))
.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}}/classes/:class/assignments/:assignment/archive")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.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}}/classes/:class/assignments/:assignment/archive');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/archive'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/archive';
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}}/classes/:class/assignments/:assignment/archive',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/archive',
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}}/classes/:class/assignments/:assignment/archive'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/classes/:class/assignments/:assignment/archive');
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}}/classes/:class/assignments/:assignment/archive'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/archive';
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}}/classes/:class/assignments/:assignment/archive"]
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}}/classes/:class/assignments/:assignment/archive" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/archive",
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}}/classes/:class/assignments/:assignment/archive');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/archive');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/archive');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/archive' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/archive' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/classes/:class/assignments/:assignment/archive")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/archive"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/archive")
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/classes/:class/assignments/:assignment/archive') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/archive";
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}}/classes/:class/assignments/:assignment/archivehttp DELETE {{baseUrl}}/classes/:class/assignments/:assignment/archivewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/archiveimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/archive")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"attachments": [
{
"score": "0000000000000000",
"type": "flat"
},
{
"type": "link",
"url": "https://flat.io/developers"
},
{
"authorName": "Flat",
"authorUrl": "https://www.youtube.com/channel/UCEUIbEP9Rba_g0r4eeGhmXw",
"description": "Discover Flat on https://flat.io",
"html": "",
"thumbnailHeight": 1052,
"thumbnailUrl": "https://i.ytimg.com/vi/SNbRUiBZ4Uw/maxresdefault.jpg",
"thumbnailWidth": 1868,
"title": "Flat - The online collaborative music notation software",
"type": "video",
"url": "https://www.youtube.com/watch?v=SNbRUiBZ4Uw"
}
],
"canvas": {
"alternateLink": "https://canvas.instructure.com/courses/00000/assignments/12345",
"id": "12345"
},
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-06-12T13:56:19.613000Z",
"creator": "5832bf149995c4024bd6de7d",
"description": "Get started with Flat",
"dueDate": "2017-07-12T13:56:19.613000Z",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/detail",
"id": "1235665432"
},
"lti": {
"id": "12345"
},
"maxPoints": 100,
"scheduledDate": "2017-06-18T13:56:19.613000Z",
"state": "active",
"submissions": [
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2017-03-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"id": "58c4955c226ffff257211a90",
"submissionDate": "2017-03-12T00:25:22.748000Z"
}
],
"title": "My first assignment"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Unarchive the class
{{baseUrl}}/classes/:class/archive
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/archive");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/classes/:class/archive")require "http/client"
url = "{{baseUrl}}/classes/:class/archive"
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}}/classes/:class/archive"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/archive");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/archive"
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/classes/:class/archive HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/classes/:class/archive")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/archive"))
.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}}/classes/:class/archive")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/classes/:class/archive")
.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}}/classes/:class/archive');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/classes/:class/archive'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/archive';
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}}/classes/:class/archive',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/archive")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/archive',
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}}/classes/:class/archive'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/classes/:class/archive');
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}}/classes/:class/archive'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/archive';
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}}/classes/:class/archive"]
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}}/classes/:class/archive" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/archive",
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}}/classes/:class/archive');
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/archive');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/classes/:class/archive');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/archive' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/archive' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/classes/:class/archive")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/archive"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/archive"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/archive")
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/classes/:class/archive') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/archive";
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}}/classes/:class/archivehttp DELETE {{baseUrl}}/classes/:class/archivewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/classes/:class/archiveimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/archive")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update a feedback comment to a submission
{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment
BODY json
{
"comment": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"comment\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment" {:content-type :json
:form-params {:comment ""}})require "http/client"
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"comment\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"),
Content = new StringContent("{\n \"comment\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"comment\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
payload := strings.NewReader("{\n \"comment\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19
{
"comment": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.setHeader("content-type", "application/json")
.setBody("{\n \"comment\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"comment\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"comment\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.header("content-type", "application/json")
.body("{\n \"comment\": \"\"\n}")
.asString(); const data = JSON.stringify({
comment: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
headers: {'content-type': 'application/json'},
data: {comment: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"comment":""}'
};
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "comment": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"comment\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({comment: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
headers: {'content-type': 'application/json'},
body: {comment: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
comment: ''
});
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}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment',
headers: {'content-type': 'application/json'},
data: {comment: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"comment":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"comment": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"comment\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'comment' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment', [
'body' => '{
"comment": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'comment' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'comment' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"comment": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"comment": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"comment\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
payload = { "comment": "" }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment"
payload <- "{\n \"comment\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"comment\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment') do |req|
req.body = "{\n \"comment\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment";
let payload = json!({"comment": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment \
--header 'content-type: application/json' \
--data '{
"comment": ""
}'echo '{
"comment": ""
}' | \
http PUT {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "comment": ""\n}' \
--output-document \
- {{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:commentimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["comment": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class/assignments/:assignment/submissions/:submission/comments/:comment")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update the class
{{baseUrl}}/classes/:class
BODY json
{
"name": "",
"section": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/classes/:class");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"name\": \"\",\n \"section\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/classes/:class" {:content-type :json
:form-params {:name ""
:section ""}})require "http/client"
url = "{{baseUrl}}/classes/:class"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/classes/:class"),
Content = new StringContent("{\n \"name\": \"\",\n \"section\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/classes/:class");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"name\": \"\",\n \"section\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/classes/:class"
payload := strings.NewReader("{\n \"name\": \"\",\n \"section\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/classes/:class HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33
{
"name": "",
"section": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/classes/:class")
.setHeader("content-type", "application/json")
.setBody("{\n \"name\": \"\",\n \"section\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/classes/:class"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"name\": \"\",\n \"section\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"name\": \"\",\n \"section\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/classes/:class")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/classes/:class")
.header("content-type", "application/json")
.body("{\n \"name\": \"\",\n \"section\": \"\"\n}")
.asString(); const data = JSON.stringify({
name: '',
section: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/classes/:class');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class',
headers: {'content-type': 'application/json'},
data: {name: '', section: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/classes/:class';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"name":"","section":""}'
};
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}}/classes/:class',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "name": "",\n "section": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"name\": \"\",\n \"section\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/classes/:class")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/classes/:class',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({name: '', section: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/classes/:class',
headers: {'content-type': 'application/json'},
body: {name: '', section: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/classes/:class');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
name: '',
section: ''
});
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}}/classes/:class',
headers: {'content-type': 'application/json'},
data: {name: '', section: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/classes/:class';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"name":"","section":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
@"section": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/classes/:class"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/classes/:class" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"name\": \"\",\n \"section\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/classes/:class",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'name' => '',
'section' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/classes/:class', [
'body' => '{
"name": "",
"section": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/classes/:class');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'name' => '',
'section' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'name' => '',
'section' => ''
]));
$request->setRequestUrl('{{baseUrl}}/classes/:class');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"name": "",
"section": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"name": "",
"section": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/classes/:class", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/classes/:class"
payload = {
"name": "",
"section": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/classes/:class"
payload <- "{\n \"name\": \"\",\n \"section\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/classes/:class")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/classes/:class') do |req|
req.body = "{\n \"name\": \"\",\n \"section\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/classes/:class";
let payload = json!({
"name": "",
"section": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/classes/:class \
--header 'content-type: application/json' \
--data '{
"name": "",
"section": ""
}'echo '{
"name": "",
"section": ""
}' | \
http PUT {{baseUrl}}/classes/:class \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "name": "",\n "section": ""\n}' \
--output-document \
- {{baseUrl}}/classes/:classimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"name": "",
"section": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/classes/:class")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"assignmentsCount": 10,
"canvas": {
"id": "000000000"
},
"creationTime": "2017-01-25T09:47:34.544000Z",
"enrollmentCode": "jm447ear",
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory",
"id": "00000000"
},
"googleDrive": {
"teacherFolderAlternateLink": "https://drive.google.com/drive/folders/0B-0000000000000000",
"teacherFolderId": "0B-0000000000000000"
},
"id": "100000000000000000000001",
"lti": {
"contextId": "042",
"contextLabel": "MUSIC",
"contextTitle": "Music Theory 101"
},
"microsoftGraph": {
"id": "00000000-0000-0000-0000-000000000000"
},
"name": "Music Theory 101",
"organization": "100000000000000000000002",
"owner": "100000000000000000000003",
"section": "Music Theory 101",
"state": "active",
"theme": "blue-8"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Add a score to the collection
{{baseUrl}}/collections/:collection/scores/:score
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection/scores/:score");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/collections/:collection/scores/:score")require "http/client"
url = "{{baseUrl}}/collections/:collection/scores/:score"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/collections/:collection/scores/:score"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection/scores/:score");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection/scores/:score"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/collections/:collection/scores/:score HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/collections/:collection/scores/:score")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection/scores/:score"))
.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}}/collections/:collection/scores/:score")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/collections/:collection/scores/:score")
.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}}/collections/:collection/scores/:score');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/collections/:collection/scores/:score'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection/scores/:score';
const options = {method: 'PUT'};
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}}/collections/:collection/scores/:score',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection/scores/:score")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection/scores/:score',
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: 'PUT',
url: '{{baseUrl}}/collections/:collection/scores/:score'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/collections/:collection/scores/:score');
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}}/collections/:collection/scores/:score'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection/scores/:score';
const options = {method: 'PUT'};
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}}/collections/:collection/scores/:score"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
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}}/collections/:collection/scores/:score" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection/scores/:score",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/collections/:collection/scores/:score');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection/scores/:score');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection/scores/:score');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection/scores/:score' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection/scores/:score' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/collections/:collection/scores/:score")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection/scores/:score"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection/scores/:score"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection/scores/:score")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/collections/:collection/scores/:score') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection/scores/:score";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/collections/:collection/scores/:scorehttp PUT {{baseUrl}}/collections/:collection/scores/:scorewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/collections/:collection/scores/:scoreimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection/scores/:score")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new collection
{{baseUrl}}/collections
BODY json
{
"privacy": "",
"title": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/collections" {:content-type :json
:form-params {:privacy ""
:title ""}})require "http/client"
url = "{{baseUrl}}/collections"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/collections"),
Content = new StringContent("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"privacy\": \"\",\n \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections"
payload := strings.NewReader("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/collections HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34
{
"privacy": "",
"title": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/collections")
.setHeader("content-type", "application/json")
.setBody("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"privacy\": \"\",\n \"title\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/collections")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/collections")
.header("content-type", "application/json")
.body("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
.asString(); const data = JSON.stringify({
privacy: '',
title: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/collections');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/collections',
headers: {'content-type': 'application/json'},
data: {privacy: '', title: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"privacy":"","title":""}'
};
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}}/collections',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "privacy": "",\n "title": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/collections")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({privacy: '', title: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/collections',
headers: {'content-type': 'application/json'},
body: {privacy: '', title: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/collections');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
privacy: '',
title: ''
});
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}}/collections',
headers: {'content-type': 'application/json'},
data: {privacy: '', title: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"privacy":"","title":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"privacy": @"",
@"title": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/collections" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"privacy\": \"\",\n \"title\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'privacy' => '',
'title' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/collections', [
'body' => '{
"privacy": "",
"title": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/collections');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'privacy' => '',
'title' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'privacy' => '',
'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/collections');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"privacy": "",
"title": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"privacy": "",
"title": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/collections", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections"
payload = {
"privacy": "",
"title": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections"
payload <- "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/collections') do |req|
req.body = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections";
let payload = json!({
"privacy": "",
"title": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/collections \
--header 'content-type: application/json' \
--data '{
"privacy": "",
"title": ""
}'echo '{
"privacy": "",
"title": ""
}' | \
http POST {{baseUrl}}/collections \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "privacy": "",\n "title": ""\n}' \
--output-document \
- {{baseUrl}}/collectionsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"privacy": "",
"title": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"rights": {
"aclAdmin": true,
"aclRead": true,
"aclWrite": true,
"isCollaborator": true
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a score from the collection
{{baseUrl}}/collections/:collection/scores/:score
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection/scores/:score");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/collections/:collection/scores/:score")require "http/client"
url = "{{baseUrl}}/collections/:collection/scores/:score"
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}}/collections/:collection/scores/:score"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection/scores/:score");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection/scores/:score"
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/collections/:collection/scores/:score HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/collections/:collection/scores/:score")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection/scores/:score"))
.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}}/collections/:collection/scores/:score")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/collections/:collection/scores/:score")
.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}}/collections/:collection/scores/:score');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/collections/:collection/scores/:score'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection/scores/:score';
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}}/collections/:collection/scores/:score',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection/scores/:score")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection/scores/:score',
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}}/collections/:collection/scores/:score'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/collections/:collection/scores/:score');
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}}/collections/:collection/scores/:score'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection/scores/:score';
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}}/collections/:collection/scores/:score"]
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}}/collections/:collection/scores/:score" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection/scores/:score",
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}}/collections/:collection/scores/:score');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection/scores/:score');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection/scores/:score');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection/scores/:score' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection/scores/:score' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/collections/:collection/scores/:score")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection/scores/:score"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection/scores/:score"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection/scores/:score")
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/collections/:collection/scores/:score') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection/scores/:score";
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}}/collections/:collection/scores/:scorehttp DELETE {{baseUrl}}/collections/:collection/scores/:scorewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/collections/:collection/scores/:scoreimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection/scores/:score")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete the collection
{{baseUrl}}/collections/:collection
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/collections/:collection")require "http/client"
url = "{{baseUrl}}/collections/:collection"
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}}/collections/:collection"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection"
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/collections/:collection HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/collections/:collection")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection"))
.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}}/collections/:collection")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/collections/:collection")
.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}}/collections/:collection');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/collections/:collection'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection';
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}}/collections/:collection',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection',
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}}/collections/:collection'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/collections/:collection');
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}}/collections/:collection'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection';
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}}/collections/:collection"]
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}}/collections/:collection" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection",
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}}/collections/:collection');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/collections/:collection")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection")
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/collections/:collection') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection";
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}}/collections/:collectionhttp DELETE {{baseUrl}}/collections/:collectionwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/collections/:collectionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get collection details
{{baseUrl}}/collections/:collection
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/collections/:collection")require "http/client"
url = "{{baseUrl}}/collections/:collection"
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}}/collections/:collection"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection"
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/collections/:collection HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection"))
.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}}/collections/:collection")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection")
.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}}/collections/:collection');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/collections/:collection'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection';
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}}/collections/:collection',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection',
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}}/collections/:collection'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/collections/:collection');
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}}/collections/:collection'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection';
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}}/collections/:collection"]
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}}/collections/:collection" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection",
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}}/collections/:collection');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/collections/:collection")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection")
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/collections/:collection') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection";
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}}/collections/:collectionhttp GET {{baseUrl}}/collections/:collectionwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/collections/:collectionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"rights": {
"aclAdmin": true,
"aclRead": true,
"aclWrite": true,
"isCollaborator": true
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the collections
{{baseUrl}}/collections
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/collections")require "http/client"
url = "{{baseUrl}}/collections"
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}}/collections"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections"
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/collections HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections"))
.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}}/collections")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/collections")
.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}}/collections');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/collections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections';
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}}/collections',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections',
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}}/collections'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/collections');
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}}/collections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections';
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}}/collections"]
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}}/collections" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections",
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}}/collections');
echo $response->getBody();setUrl('{{baseUrl}}/collections');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/collections")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections")
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/collections') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections";
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}}/collectionshttp GET {{baseUrl}}/collectionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/collectionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"rights": {
"aclAdmin": true,
"aclRead": true,
"aclWrite": true,
"isCollaborator": true
}
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the scores contained in a collection
{{baseUrl}}/collections/:collection/scores
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection/scores");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/collections/:collection/scores")require "http/client"
url = "{{baseUrl}}/collections/:collection/scores"
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}}/collections/:collection/scores"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection/scores");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection/scores"
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/collections/:collection/scores HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:collection/scores")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection/scores"))
.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}}/collections/:collection/scores")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/collections/:collection/scores")
.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}}/collections/:collection/scores');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/collections/:collection/scores'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection/scores';
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}}/collections/:collection/scores',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection/scores")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection/scores',
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}}/collections/:collection/scores'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/collections/:collection/scores');
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}}/collections/:collection/scores'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection/scores';
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}}/collections/:collection/scores"]
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}}/collections/:collection/scores" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection/scores",
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}}/collections/:collection/scores');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection/scores');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection/scores');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection/scores' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection/scores' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/collections/:collection/scores")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection/scores"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection/scores"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection/scores")
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/collections/:collection/scores') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection/scores";
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}}/collections/:collection/scoreshttp GET {{baseUrl}}/collections/:collection/scoreswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/collections/:collection/scoresimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection/scores")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Untrash a collection
{{baseUrl}}/collections/:collection/untrash
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection/untrash");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/collections/:collection/untrash")require "http/client"
url = "{{baseUrl}}/collections/:collection/untrash"
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}}/collections/:collection/untrash"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection/untrash");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection/untrash"
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/collections/:collection/untrash HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/collections/:collection/untrash")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection/untrash"))
.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}}/collections/:collection/untrash")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/collections/:collection/untrash")
.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}}/collections/:collection/untrash');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/collections/:collection/untrash'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection/untrash';
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}}/collections/:collection/untrash',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection/untrash")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection/untrash',
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}}/collections/:collection/untrash'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/collections/:collection/untrash');
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}}/collections/:collection/untrash'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection/untrash';
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}}/collections/:collection/untrash"]
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}}/collections/:collection/untrash" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection/untrash",
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}}/collections/:collection/untrash');
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection/untrash');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:collection/untrash');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection/untrash' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection/untrash' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/collections/:collection/untrash")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection/untrash"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection/untrash"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection/untrash")
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/collections/:collection/untrash') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection/untrash";
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}}/collections/:collection/untrashhttp POST {{baseUrl}}/collections/:collection/untrashwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/collections/:collection/untrashimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection/untrash")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update a collection's metadata
{{baseUrl}}/collections/:collection
BODY json
{
"privacy": "",
"title": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:collection");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/collections/:collection" {:content-type :json
:form-params {:privacy ""
:title ""}})require "http/client"
url = "{{baseUrl}}/collections/:collection"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/collections/:collection"),
Content = new StringContent("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:collection");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"privacy\": \"\",\n \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:collection"
payload := strings.NewReader("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/collections/:collection HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34
{
"privacy": "",
"title": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/collections/:collection")
.setHeader("content-type", "application/json")
.setBody("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:collection"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"privacy\": \"\",\n \"title\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/collections/:collection")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/collections/:collection")
.header("content-type", "application/json")
.body("{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
.asString(); const data = JSON.stringify({
privacy: '',
title: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/collections/:collection');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/collections/:collection',
headers: {'content-type': 'application/json'},
data: {privacy: '', title: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:collection';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"privacy":"","title":""}'
};
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}}/collections/:collection',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "privacy": "",\n "title": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"privacy\": \"\",\n \"title\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/collections/:collection")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:collection',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({privacy: '', title: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/collections/:collection',
headers: {'content-type': 'application/json'},
body: {privacy: '', title: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/collections/:collection');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
privacy: '',
title: ''
});
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}}/collections/:collection',
headers: {'content-type': 'application/json'},
data: {privacy: '', title: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:collection';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"privacy":"","title":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"privacy": @"",
@"title": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:collection"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/collections/:collection" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"privacy\": \"\",\n \"title\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:collection",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'privacy' => '',
'title' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/collections/:collection', [
'body' => '{
"privacy": "",
"title": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/collections/:collection');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'privacy' => '',
'title' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'privacy' => '',
'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/collections/:collection');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:collection' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"privacy": "",
"title": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:collection' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"privacy": "",
"title": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/collections/:collection", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:collection"
payload = {
"privacy": "",
"title": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:collection"
payload <- "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:collection")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/collections/:collection') do |req|
req.body = "{\n \"privacy\": \"\",\n \"title\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:collection";
let payload = json!({
"privacy": "",
"title": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/collections/:collection \
--header 'content-type: application/json' \
--data '{
"privacy": "",
"title": ""
}'echo '{
"privacy": "",
"title": ""
}' | \
http PUT {{baseUrl}}/collections/:collection \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "privacy": "",\n "title": ""\n}' \
--output-document \
- {{baseUrl}}/collections/:collectionimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"privacy": "",
"title": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:collection")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"rights": {
"aclAdmin": true,
"aclRead": true,
"aclWrite": true,
"isCollaborator": true
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get group information
{{baseUrl}}/groups/:group
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:group");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:group")require "http/client"
url = "{{baseUrl}}/groups/:group"
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}}/groups/:group"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:group");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:group"
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/groups/:group HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:group")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:group"))
.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}}/groups/:group")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:group")
.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}}/groups/:group');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:group'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:group';
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}}/groups/:group',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:group")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:group',
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}}/groups/:group'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:group');
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}}/groups/:group'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:group';
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}}/groups/:group"]
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}}/groups/:group" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:group",
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}}/groups/:group');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:group');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:group');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:group' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:group' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:group")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:group"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:group"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:group")
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/groups/:group') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:group";
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}}/groups/:grouphttp GET {{baseUrl}}/groups/:groupwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:groupimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:group")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"creationDate": "2017-07-02T15:02:40.207000Z",
"id": "58c4955c226ffff257211a00",
"name": "5th Grade - Teachers",
"organization": "0000000000000000000000042",
"readOnly": false,
"type": "classTeachers",
"usersCount": 2
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List group's scores
{{baseUrl}}/groups/:group/scores
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:group/scores");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:group/scores")require "http/client"
url = "{{baseUrl}}/groups/:group/scores"
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}}/groups/:group/scores"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:group/scores");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:group/scores"
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/groups/:group/scores HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:group/scores")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:group/scores"))
.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}}/groups/:group/scores")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:group/scores")
.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}}/groups/:group/scores');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:group/scores'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:group/scores';
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}}/groups/:group/scores',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:group/scores")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:group/scores',
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}}/groups/:group/scores'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:group/scores');
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}}/groups/:group/scores'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:group/scores';
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}}/groups/:group/scores"]
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}}/groups/:group/scores" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:group/scores",
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}}/groups/:group/scores');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:group/scores');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:group/scores');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:group/scores' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:group/scores' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:group/scores")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:group/scores"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:group/scores"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:group/scores")
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/groups/:group/scores') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:group/scores";
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}}/groups/:group/scoreshttp GET {{baseUrl}}/groups/:group/scoreswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:group/scoresimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:group/scores")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List group's users
{{baseUrl}}/groups/:group/users
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:group/users");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:group/users")require "http/client"
url = "{{baseUrl}}/groups/:group/users"
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}}/groups/:group/users"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:group/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:group/users"
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/groups/:group/users HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:group/users")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:group/users"))
.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}}/groups/:group/users")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:group/users")
.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}}/groups/:group/users');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:group/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:group/users';
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}}/groups/:group/users',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:group/users")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:group/users',
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}}/groups/:group/users'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:group/users');
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}}/groups/:group/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:group/users';
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}}/groups/:group/users"]
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}}/groups/:group/users" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:group/users",
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}}/groups/:group/users');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:group/users');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:group/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:group/users' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:group/users' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:group/users")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:group/users"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:group/users"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:group/users")
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/groups/:group/users') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:group/users";
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}}/groups/:group/usershttp GET {{baseUrl}}/groups/:group/userswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:group/usersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:group/users")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Count the organization users using the provided filters
{{baseUrl}}/organizations/users/count
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/users/count");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/organizations/users/count")require "http/client"
url = "{{baseUrl}}/organizations/users/count"
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}}/organizations/users/count"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/users/count");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/users/count"
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/organizations/users/count HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/organizations/users/count")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/users/count"))
.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}}/organizations/users/count")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/organizations/users/count")
.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}}/organizations/users/count');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/organizations/users/count'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/users/count';
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}}/organizations/users/count',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/users/count")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/users/count',
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}}/organizations/users/count'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/organizations/users/count');
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}}/organizations/users/count'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/users/count';
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}}/organizations/users/count"]
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}}/organizations/users/count" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/users/count",
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}}/organizations/users/count');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/users/count');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/users/count');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/users/count' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/users/count' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/organizations/users/count")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/users/count"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/users/count"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/users/count")
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/organizations/users/count') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/users/count";
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}}/organizations/users/counthttp GET {{baseUrl}}/organizations/users/countwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/organizations/users/countimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/users/count")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new couple of LTI 1.x credentials
{{baseUrl}}/organizations/lti/credentials
BODY json
{
"lms": "",
"name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/lti/credentials");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"lms\": \"\",\n \"name\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/organizations/lti/credentials" {:content-type :json
:form-params {:lms ""
:name ""}})require "http/client"
url = "{{baseUrl}}/organizations/lti/credentials"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"lms\": \"\",\n \"name\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/organizations/lti/credentials"),
Content = new StringContent("{\n \"lms\": \"\",\n \"name\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/lti/credentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"lms\": \"\",\n \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/lti/credentials"
payload := strings.NewReader("{\n \"lms\": \"\",\n \"name\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/organizations/lti/credentials HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 29
{
"lms": "",
"name": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organizations/lti/credentials")
.setHeader("content-type", "application/json")
.setBody("{\n \"lms\": \"\",\n \"name\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/lti/credentials"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"lms\": \"\",\n \"name\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"lms\": \"\",\n \"name\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/organizations/lti/credentials")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/organizations/lti/credentials")
.header("content-type", "application/json")
.body("{\n \"lms\": \"\",\n \"name\": \"\"\n}")
.asString(); const data = JSON.stringify({
lms: '',
name: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/organizations/lti/credentials');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/lti/credentials',
headers: {'content-type': 'application/json'},
data: {lms: '', name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/lti/credentials';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"lms":"","name":""}'
};
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}}/organizations/lti/credentials',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "lms": "",\n "name": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"lms\": \"\",\n \"name\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/organizations/lti/credentials")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/lti/credentials',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({lms: '', name: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/lti/credentials',
headers: {'content-type': 'application/json'},
body: {lms: '', name: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/organizations/lti/credentials');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
lms: '',
name: ''
});
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}}/organizations/lti/credentials',
headers: {'content-type': 'application/json'},
data: {lms: '', name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/lti/credentials';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"lms":"","name":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"lms": @"",
@"name": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/lti/credentials"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/organizations/lti/credentials" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"lms\": \"\",\n \"name\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/lti/credentials",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'lms' => '',
'name' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/organizations/lti/credentials', [
'body' => '{
"lms": "",
"name": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/organizations/lti/credentials');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'lms' => '',
'name' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'lms' => '',
'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organizations/lti/credentials');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/lti/credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"lms": "",
"name": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/lti/credentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"lms": "",
"name": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"lms\": \"\",\n \"name\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/organizations/lti/credentials", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/lti/credentials"
payload = {
"lms": "",
"name": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/lti/credentials"
payload <- "{\n \"lms\": \"\",\n \"name\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/lti/credentials")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"lms\": \"\",\n \"name\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/organizations/lti/credentials') do |req|
req.body = "{\n \"lms\": \"\",\n \"name\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/lti/credentials";
let payload = json!({
"lms": "",
"name": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/organizations/lti/credentials \
--header 'content-type: application/json' \
--data '{
"lms": "",
"name": ""
}'echo '{
"lms": "",
"name": ""
}' | \
http POST {{baseUrl}}/organizations/lti/credentials \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "lms": "",\n "name": ""\n}' \
--output-document \
- {{baseUrl}}/organizations/lti/credentialsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"lms": "",
"name": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/lti/credentials")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"consumerKey": "200082F5-FAFD-4C6E-BB19-7DAB5D6264D4",
"consumerSecret": "168b6181c05eae14298176a274273e4ebef0d15555fe3e80c6a98ccd57d0c3b6",
"creationDate": "2017-06-06T11:03:01.955000Z",
"creator": "5832bf149995c4024bd6de7d",
"id": "59368be5c66caf895ee02387",
"lastUsage": "2017-06-13T16:02:34.324000Z",
"lms": "canvas",
"name": "My couple of credentials for Canvas",
"organization": "5832c801a4bedc05f4fb4993"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new invitation to join the organization
{{baseUrl}}/organizations/invitations
BODY json
{
"email": "",
"organizationRole": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/invitations");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/organizations/invitations" {:content-type :json
:form-params {:email ""
:organizationRole ""}})require "http/client"
url = "{{baseUrl}}/organizations/invitations"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/organizations/invitations"),
Content = new StringContent("{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/invitations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/invitations"
payload := strings.NewReader("{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/organizations/invitations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 43
{
"email": "",
"organizationRole": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organizations/invitations")
.setHeader("content-type", "application/json")
.setBody("{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/invitations"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/organizations/invitations")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/organizations/invitations")
.header("content-type", "application/json")
.body("{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}")
.asString(); const data = JSON.stringify({
email: '',
organizationRole: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/organizations/invitations');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/invitations',
headers: {'content-type': 'application/json'},
data: {email: '', organizationRole: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/invitations';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"email":"","organizationRole":""}'
};
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}}/organizations/invitations',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "email": "",\n "organizationRole": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/organizations/invitations")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/invitations',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({email: '', organizationRole: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/invitations',
headers: {'content-type': 'application/json'},
body: {email: '', organizationRole: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/organizations/invitations');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
email: '',
organizationRole: ''
});
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}}/organizations/invitations',
headers: {'content-type': 'application/json'},
data: {email: '', organizationRole: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/invitations';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"email":"","organizationRole":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
@"organizationRole": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/invitations"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/organizations/invitations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/invitations",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'email' => '',
'organizationRole' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/organizations/invitations', [
'body' => '{
"email": "",
"organizationRole": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/organizations/invitations');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'email' => '',
'organizationRole' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'email' => '',
'organizationRole' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organizations/invitations');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/invitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"organizationRole": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/invitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"organizationRole": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/organizations/invitations", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/invitations"
payload = {
"email": "",
"organizationRole": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/invitations"
payload <- "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/invitations")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/organizations/invitations') do |req|
req.body = "{\n \"email\": \"\",\n \"organizationRole\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/invitations";
let payload = json!({
"email": "",
"organizationRole": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/organizations/invitations \
--header 'content-type: application/json' \
--data '{
"email": "",
"organizationRole": ""
}'echo '{
"email": "",
"organizationRole": ""
}' | \
http POST {{baseUrl}}/organizations/invitations \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "email": "",\n "organizationRole": ""\n}' \
--output-document \
- {{baseUrl}}/organizations/invitationsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"email": "",
"organizationRole": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/invitations")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"creationDate": "2017-07-02T15:05:15.576000Z",
"customCode": "u5raQ7pZ",
"email": "edu@flat.io",
"id": "59590bab53b1af260610000",
"invitedBy": "55b8d8f395c8db031ed00000",
"organization": "55df29a6694e4a3953100000",
"organizationRole": "teacher"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new user account
{{baseUrl}}/organizations/users
BODY json
{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/users");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/organizations/users" {:content-type :json
:form-params {:email ""
:firstname ""
:lastname ""
:locale ""
:password ""
:username ""}})require "http/client"
url = "{{baseUrl}}/organizations/users"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/organizations/users"),
Content = new StringContent("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/users"
payload := strings.NewReader("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/organizations/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 106
{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organizations/users")
.setHeader("content-type", "application/json")
.setBody("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/users"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/organizations/users")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/organizations/users")
.header("content-type", "application/json")
.body("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
.asString(); const data = JSON.stringify({
email: '',
firstname: '',
lastname: '',
locale: '',
password: '',
username: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/organizations/users');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/users',
headers: {'content-type': 'application/json'},
data: {email: '', firstname: '', lastname: '', locale: '', password: '', username: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/users';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"email":"","firstname":"","lastname":"","locale":"","password":"","username":""}'
};
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}}/organizations/users',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "email": "",\n "firstname": "",\n "lastname": "",\n "locale": "",\n "password": "",\n "username": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/organizations/users")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/users',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({email: '', firstname: '', lastname: '', locale: '', password: '', username: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/organizations/users',
headers: {'content-type': 'application/json'},
body: {email: '', firstname: '', lastname: '', locale: '', password: '', username: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/organizations/users');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
email: '',
firstname: '',
lastname: '',
locale: '',
password: '',
username: ''
});
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}}/organizations/users',
headers: {'content-type': 'application/json'},
data: {email: '', firstname: '', lastname: '', locale: '', password: '', username: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/users';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"email":"","firstname":"","lastname":"","locale":"","password":"","username":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
@"firstname": @"",
@"lastname": @"",
@"locale": @"",
@"password": @"",
@"username": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/users"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/organizations/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/users",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'locale' => '',
'password' => '',
'username' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/organizations/users', [
'body' => '{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/organizations/users');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'locale' => '',
'password' => '',
'username' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'locale' => '',
'password' => '',
'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organizations/users');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/organizations/users", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/users"
payload = {
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/users"
payload <- "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/users")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/organizations/users') do |req|
req.body = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"locale\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/users";
let payload = json!({
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/organizations/users \
--header 'content-type: application/json' \
--data '{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}'echo '{
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
}' | \
http POST {{baseUrl}}/organizations/users \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "email": "",\n "firstname": "",\n "lastname": "",\n "locale": "",\n "password": "",\n "username": ""\n}' \
--output-document \
- {{baseUrl}}/organizations/usersimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"email": "",
"firstname": "",
"lastname": "",
"locale": "",
"password": "",
"username": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/users")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List LTI 1.x credentials
{{baseUrl}}/organizations/lti/credentials
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/lti/credentials");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/organizations/lti/credentials")require "http/client"
url = "{{baseUrl}}/organizations/lti/credentials"
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}}/organizations/lti/credentials"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/lti/credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/lti/credentials"
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/organizations/lti/credentials HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/organizations/lti/credentials")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/lti/credentials"))
.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}}/organizations/lti/credentials")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/organizations/lti/credentials")
.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}}/organizations/lti/credentials');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/organizations/lti/credentials'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/lti/credentials';
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}}/organizations/lti/credentials',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/lti/credentials")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/lti/credentials',
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}}/organizations/lti/credentials'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/organizations/lti/credentials');
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}}/organizations/lti/credentials'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/lti/credentials';
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}}/organizations/lti/credentials"]
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}}/organizations/lti/credentials" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/lti/credentials",
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}}/organizations/lti/credentials');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/lti/credentials');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/lti/credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/lti/credentials' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/lti/credentials' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/organizations/lti/credentials")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/lti/credentials"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/lti/credentials"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/lti/credentials")
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/organizations/lti/credentials') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/lti/credentials";
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}}/organizations/lti/credentialshttp GET {{baseUrl}}/organizations/lti/credentialswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/organizations/lti/credentialsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/lti/credentials")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"consumerKey": "200082F5-FAFD-4C6E-BB19-7DAB5D6264D4",
"consumerSecret": "168b6181c05eae14298176a274273e4ebef0d15555fe3e80c6a98ccd57d0c3b6",
"creationDate": "2017-06-06T11:03:01.955000Z",
"creator": "5832bf149995c4024bd6de7d",
"id": "59368be5c66caf895ee02387",
"lastUsage": "2017-06-13T16:02:34.324000Z",
"lms": "canvas",
"name": "My couple of credentials for Canvas",
"organization": "5832c801a4bedc05f4fb4993"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the organization invitations
{{baseUrl}}/organizations/invitations
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/invitations");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/organizations/invitations")require "http/client"
url = "{{baseUrl}}/organizations/invitations"
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}}/organizations/invitations"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/invitations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/invitations"
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/organizations/invitations HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/organizations/invitations")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/invitations"))
.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}}/organizations/invitations")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/organizations/invitations")
.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}}/organizations/invitations');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/organizations/invitations'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/invitations';
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}}/organizations/invitations',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/invitations")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/invitations',
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}}/organizations/invitations'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/organizations/invitations');
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}}/organizations/invitations'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/invitations';
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}}/organizations/invitations"]
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}}/organizations/invitations" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/invitations",
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}}/organizations/invitations');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/invitations');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/invitations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/invitations' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/invitations' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/organizations/invitations")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/invitations"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/invitations"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/invitations")
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/organizations/invitations') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/invitations";
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}}/organizations/invitationshttp GET {{baseUrl}}/organizations/invitationswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/organizations/invitationsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/invitations")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"creationDate": "2017-07-02T15:05:15.576000Z",
"customCode": "u5raQ7pZ",
"email": "edu@flat.io",
"id": "59590bab53b1af260610000",
"invitedBy": "55b8d8f395c8db031ed00000",
"organization": "55df29a6694e4a3953100000",
"organizationRole": "teacher"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the organization users
{{baseUrl}}/organizations/users
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/users");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/organizations/users")require "http/client"
url = "{{baseUrl}}/organizations/users"
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}}/organizations/users"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/users"
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/organizations/users HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/organizations/users")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/users"))
.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}}/organizations/users")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/organizations/users")
.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}}/organizations/users');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/organizations/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/users';
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}}/organizations/users',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/users")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/users',
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}}/organizations/users'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/organizations/users');
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}}/organizations/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/users';
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}}/organizations/users"]
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}}/organizations/users" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/users",
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}}/organizations/users');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/users');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/users' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/users' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/organizations/users")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/users"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/users"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/users")
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/organizations/users') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/users";
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}}/organizations/usershttp GET {{baseUrl}}/organizations/userswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/organizations/usersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/users")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Remove an account from Flat
{{baseUrl}}/organizations/users/:user
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/users/:user");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/organizations/users/:user")require "http/client"
url = "{{baseUrl}}/organizations/users/:user"
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}}/organizations/users/:user"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/users/:user");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/users/:user"
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/organizations/users/:user HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/users/:user")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/users/:user"))
.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}}/organizations/users/:user")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/users/:user")
.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}}/organizations/users/:user');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/organizations/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/users/:user';
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}}/organizations/users/:user',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/users/:user")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/users/:user',
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}}/organizations/users/:user'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/organizations/users/:user');
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}}/organizations/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/users/:user';
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}}/organizations/users/:user"]
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}}/organizations/users/:user" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/users/:user",
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}}/organizations/users/:user');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/users/:user');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/users/:user');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/users/:user' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/users/:user' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/organizations/users/:user")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/users/:user"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/users/:user"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/users/:user")
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/organizations/users/:user') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/users/:user";
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}}/organizations/users/:userhttp DELETE {{baseUrl}}/organizations/users/:userwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/organizations/users/:userimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/users/:user")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Remove an organization invitation
{{baseUrl}}/organizations/invitations/:invitation
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/invitations/:invitation");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/organizations/invitations/:invitation")require "http/client"
url = "{{baseUrl}}/organizations/invitations/:invitation"
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}}/organizations/invitations/:invitation"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/invitations/:invitation");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/invitations/:invitation"
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/organizations/invitations/:invitation HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/invitations/:invitation")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/invitations/:invitation"))
.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}}/organizations/invitations/:invitation")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/invitations/:invitation")
.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}}/organizations/invitations/:invitation');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/organizations/invitations/:invitation'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/invitations/:invitation';
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}}/organizations/invitations/:invitation',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/invitations/:invitation")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/invitations/:invitation',
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}}/organizations/invitations/:invitation'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/organizations/invitations/:invitation');
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}}/organizations/invitations/:invitation'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/invitations/:invitation';
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}}/organizations/invitations/:invitation"]
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}}/organizations/invitations/:invitation" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/invitations/:invitation",
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}}/organizations/invitations/:invitation');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/invitations/:invitation');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/invitations/:invitation');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/invitations/:invitation' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/invitations/:invitation' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/organizations/invitations/:invitation")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/invitations/:invitation"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/invitations/:invitation"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/invitations/:invitation")
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/organizations/invitations/:invitation') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/invitations/:invitation";
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}}/organizations/invitations/:invitationhttp DELETE {{baseUrl}}/organizations/invitations/:invitationwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/organizations/invitations/:invitationimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/invitations/:invitation")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Revoke LTI 1.x credentials
{{baseUrl}}/organizations/lti/credentials/:credentials
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/lti/credentials/:credentials");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/organizations/lti/credentials/:credentials")require "http/client"
url = "{{baseUrl}}/organizations/lti/credentials/:credentials"
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}}/organizations/lti/credentials/:credentials"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/lti/credentials/:credentials");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/lti/credentials/:credentials"
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/organizations/lti/credentials/:credentials HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/lti/credentials/:credentials")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/lti/credentials/:credentials"))
.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}}/organizations/lti/credentials/:credentials")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/lti/credentials/:credentials")
.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}}/organizations/lti/credentials/:credentials');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/organizations/lti/credentials/:credentials'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/lti/credentials/:credentials';
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}}/organizations/lti/credentials/:credentials',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/organizations/lti/credentials/:credentials")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/lti/credentials/:credentials',
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}}/organizations/lti/credentials/:credentials'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/organizations/lti/credentials/:credentials');
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}}/organizations/lti/credentials/:credentials'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/lti/credentials/:credentials';
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}}/organizations/lti/credentials/:credentials"]
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}}/organizations/lti/credentials/:credentials" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/lti/credentials/:credentials",
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}}/organizations/lti/credentials/:credentials');
echo $response->getBody();setUrl('{{baseUrl}}/organizations/lti/credentials/:credentials');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/organizations/lti/credentials/:credentials');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/lti/credentials/:credentials' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/lti/credentials/:credentials' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/organizations/lti/credentials/:credentials")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/lti/credentials/:credentials"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/lti/credentials/:credentials"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/lti/credentials/:credentials")
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/organizations/lti/credentials/:credentials') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/lti/credentials/:credentials";
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}}/organizations/lti/credentials/:credentialshttp DELETE {{baseUrl}}/organizations/lti/credentials/:credentialswget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/organizations/lti/credentials/:credentialsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/lti/credentials/:credentials")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update account information
{{baseUrl}}/organizations/users/:user
BODY json
{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/users/:user");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/organizations/users/:user" {:content-type :json
:form-params {:email ""
:firstname ""
:lastname ""
:organizationRole ""
:password ""
:username ""}})require "http/client"
url = "{{baseUrl}}/organizations/users/:user"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/organizations/users/:user"),
Content = new StringContent("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/organizations/users/:user");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/organizations/users/:user"
payload := strings.NewReader("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/organizations/users/:user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 116
{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/organizations/users/:user")
.setHeader("content-type", "application/json")
.setBody("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/organizations/users/:user"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/organizations/users/:user")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/organizations/users/:user")
.header("content-type", "application/json")
.body("{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
.asString(); const data = JSON.stringify({
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/organizations/users/:user');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/organizations/users/:user',
headers: {'content-type': 'application/json'},
data: {
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/organizations/users/:user';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"email":"","firstname":"","lastname":"","organizationRole":"","password":"","username":""}'
};
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}}/organizations/users/:user',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "email": "",\n "firstname": "",\n "lastname": "",\n "organizationRole": "",\n "password": "",\n "username": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/organizations/users/:user")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/organizations/users/:user',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/organizations/users/:user',
headers: {'content-type': 'application/json'},
body: {
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/organizations/users/:user');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
});
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}}/organizations/users/:user',
headers: {'content-type': 'application/json'},
data: {
email: '',
firstname: '',
lastname: '',
organizationRole: '',
password: '',
username: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/organizations/users/:user';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"email":"","firstname":"","lastname":"","organizationRole":"","password":"","username":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"email": @"",
@"firstname": @"",
@"lastname": @"",
@"organizationRole": @"",
@"password": @"",
@"username": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/users/:user"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/organizations/users/:user" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/organizations/users/:user",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'organizationRole' => '',
'password' => '',
'username' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/organizations/users/:user', [
'body' => '{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/organizations/users/:user');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'organizationRole' => '',
'password' => '',
'username' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'email' => '',
'firstname' => '',
'lastname' => '',
'organizationRole' => '',
'password' => '',
'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organizations/users/:user');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/users/:user' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/users/:user' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/organizations/users/:user", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/organizations/users/:user"
payload = {
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/organizations/users/:user"
payload <- "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/organizations/users/:user")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/organizations/users/:user') do |req|
req.body = "{\n \"email\": \"\",\n \"firstname\": \"\",\n \"lastname\": \"\",\n \"organizationRole\": \"\",\n \"password\": \"\",\n \"username\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/organizations/users/:user";
let payload = json!({
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/organizations/users/:user \
--header 'content-type: application/json' \
--data '{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}'echo '{
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
}' | \
http PUT {{baseUrl}}/organizations/users/:user \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "email": "",\n "firstname": "",\n "lastname": "",\n "organizationRole": "",\n "password": "",\n "username": ""\n}' \
--output-document \
- {{baseUrl}}/organizations/users/:userimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"email": "",
"firstname": "",
"lastname": "",
"organizationRole": "",
"password": "",
"username": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/users/:user")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Add a new collaborator
{{baseUrl}}/scores/:score/collaborators
BODY json
{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/collaborators");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/collaborators" {:content-type :json
:form-params {:aclAdmin false
:aclRead false
:aclWrite false
:group ""
:user ""
:userEmail ""
:userToken ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/collaborators"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores/:score/collaborators"),
Content = new StringContent("{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/collaborators");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/collaborators"
payload := strings.NewReader("{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores/:score/collaborators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 131
{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/collaborators")
.setHeader("content-type", "application/json")
.setBody("{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/collaborators"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/collaborators")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/collaborators")
.header("content-type", "application/json")
.body("{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}")
.asString(); const data = JSON.stringify({
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores/:score/collaborators');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/collaborators',
headers: {'content-type': 'application/json'},
data: {
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/collaborators';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"aclAdmin":false,"aclRead":false,"aclWrite":false,"group":"","user":"","userEmail":"","userToken":""}'
};
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}}/scores/:score/collaborators',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "aclAdmin": false,\n "aclRead": false,\n "aclWrite": false,\n "group": "",\n "user": "",\n "userEmail": "",\n "userToken": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/collaborators")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/collaborators',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/collaborators',
headers: {'content-type': 'application/json'},
body: {
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/collaborators');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
});
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}}/scores/:score/collaborators',
headers: {'content-type': 'application/json'},
data: {
aclAdmin: false,
aclRead: false,
aclWrite: false,
group: '',
user: '',
userEmail: '',
userToken: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/collaborators';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"aclAdmin":false,"aclRead":false,"aclWrite":false,"group":"","user":"","userEmail":"","userToken":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"aclAdmin": @NO,
@"aclRead": @NO,
@"aclWrite": @NO,
@"group": @"",
@"user": @"",
@"userEmail": @"",
@"userToken": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/collaborators"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/collaborators" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/collaborators",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'aclAdmin' => null,
'aclRead' => null,
'aclWrite' => null,
'group' => '',
'user' => '',
'userEmail' => '',
'userToken' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores/:score/collaborators', [
'body' => '{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/collaborators');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'aclAdmin' => null,
'aclRead' => null,
'aclWrite' => null,
'group' => '',
'user' => '',
'userEmail' => '',
'userToken' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'aclAdmin' => null,
'aclRead' => null,
'aclWrite' => null,
'group' => '',
'user' => '',
'userEmail' => '',
'userToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/collaborators');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/collaborators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/collaborators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores/:score/collaborators", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/collaborators"
payload = {
"aclAdmin": False,
"aclRead": False,
"aclWrite": False,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/collaborators"
payload <- "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/collaborators")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores/:score/collaborators') do |req|
req.body = "{\n \"aclAdmin\": false,\n \"aclRead\": false,\n \"aclWrite\": false,\n \"group\": \"\",\n \"user\": \"\",\n \"userEmail\": \"\",\n \"userToken\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/collaborators";
let payload = json!({
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores/:score/collaborators \
--header 'content-type: application/json' \
--data '{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}'echo '{
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
}' | \
http POST {{baseUrl}}/scores/:score/collaborators \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "aclAdmin": false,\n "aclRead": false,\n "aclWrite": false,\n "group": "",\n "user": "",\n "userEmail": "",\n "userToken": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/collaboratorsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"aclAdmin": false,
"aclRead": false,
"aclWrite": false,
"group": "",
"user": "",
"userEmail": "",
"userToken": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/collaborators")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Add a new video or audio track to the score
{{baseUrl}}/scores/:score/tracks
BODY json
{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/tracks" {:content-type :json
:form-params {:default false
:state ""
:synchronizationPoints [{:measureUuid ""
:time ""
:type ""}]
:title ""
:url ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/tracks"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores/:score/tracks"),
Content = new StringContent("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/tracks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/tracks"
payload := strings.NewReader("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores/:score/tracks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 171
{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/tracks")
.setHeader("content-type", "application/json")
.setBody("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/tracks"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/tracks")
.header("content-type", "application/json")
.body("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}")
.asString(); const data = JSON.stringify({
default: false,
state: '',
synchronizationPoints: [
{
measureUuid: '',
time: '',
type: ''
}
],
title: '',
url: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores/:score/tracks');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/tracks',
headers: {'content-type': 'application/json'},
data: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: '',
url: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/tracks';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"default":false,"state":"","synchronizationPoints":[{"measureUuid":"","time":"","type":""}],"title":"","url":""}'
};
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}}/scores/:score/tracks',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "default": false,\n "state": "",\n "synchronizationPoints": [\n {\n "measureUuid": "",\n "time": "",\n "type": ""\n }\n ],\n "title": "",\n "url": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/tracks',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: '',
url: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/tracks',
headers: {'content-type': 'application/json'},
body: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: '',
url: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/tracks');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
default: false,
state: '',
synchronizationPoints: [
{
measureUuid: '',
time: '',
type: ''
}
],
title: '',
url: ''
});
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}}/scores/:score/tracks',
headers: {'content-type': 'application/json'},
data: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: '',
url: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/tracks';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"default":false,"state":"","synchronizationPoints":[{"measureUuid":"","time":"","type":""}],"title":"","url":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"default": @NO,
@"state": @"",
@"synchronizationPoints": @[ @{ @"measureUuid": @"", @"time": @"", @"type": @"" } ],
@"title": @"",
@"url": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/tracks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => '',
'url' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores/:score/tracks', [
'body' => '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/tracks');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => '',
'url' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => '',
'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/tracks');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/tracks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/tracks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores/:score/tracks", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/tracks"
payload = {
"default": False,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/tracks"
payload <- "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores/:score/tracks') do |req|
req.body = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\",\n \"url\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/tracks";
let payload = json!({
"default": false,
"state": "",
"synchronizationPoints": (
json!({
"measureUuid": "",
"time": "",
"type": ""
})
),
"title": "",
"url": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores/:score/tracks \
--header 'content-type: application/json' \
--data '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}'echo '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": "",
"url": ""
}' | \
http POST {{baseUrl}}/scores/:score/tracks \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "default": false,\n "state": "",\n "synchronizationPoints": [\n {\n "measureUuid": "",\n "time": "",\n "type": ""\n }\n ],\n "title": "",\n "url": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/tracksimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"default": false,
"state": "",
"synchronizationPoints": [
[
"measureUuid": "",
"time": "",
"type": ""
]
],
"title": "",
"url": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"creationDate": "2017-10-22T14:58:22.753000Z",
"creator": "5815d4b53269d90d2c80b71c",
"default": true,
"id": "59ecb20e563736b1e1f75dce",
"mediaId": "dQw4w9WgXcQ",
"modificationDate": "2017-10-22T14:58:33.424000Z",
"score": "59a29d96f35a6411d7508bdd",
"state": "completed",
"synchronizationPoints": [
{
"measureUuid": "5132a788-69e6-d0c6-84ec-4bd858658d7c",
"time": 0,
"type": "measure"
},
{
"time": 213,
"type": "end"
}
],
"title": "Rick Astley - Never Gonna Give You Up",
"type": "youtube",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new revision
{{baseUrl}}/scores/:score/revisions
BODY json
{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/revisions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/revisions" {:content-type :json
:form-params {:autosave false
:data ""
:dataEncoding ""
:description ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/revisions"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores/:score/revisions"),
Content = new StringContent("{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/revisions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/revisions"
payload := strings.NewReader("{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores/:score/revisions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 80
{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/revisions")
.setHeader("content-type", "application/json")
.setBody("{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/revisions"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/revisions")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/revisions")
.header("content-type", "application/json")
.body("{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}")
.asString(); const data = JSON.stringify({
autosave: false,
data: '',
dataEncoding: '',
description: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores/:score/revisions');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/revisions',
headers: {'content-type': 'application/json'},
data: {autosave: false, data: '', dataEncoding: '', description: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/revisions';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"autosave":false,"data":"","dataEncoding":"","description":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/scores/:score/revisions',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "autosave": false,\n "data": "",\n "dataEncoding": "",\n "description": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/revisions")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/revisions',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({autosave: false, data: '', dataEncoding: '', description: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/revisions',
headers: {'content-type': 'application/json'},
body: {autosave: false, data: '', dataEncoding: '', description: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/revisions');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
autosave: false,
data: '',
dataEncoding: '',
description: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/revisions',
headers: {'content-type': 'application/json'},
data: {autosave: false, data: '', dataEncoding: '', description: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/revisions';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"autosave":false,"data":"","dataEncoding":"","description":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"autosave": @NO,
@"data": @"",
@"dataEncoding": @"",
@"description": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/revisions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/revisions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/revisions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'autosave' => null,
'data' => '',
'dataEncoding' => '',
'description' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores/:score/revisions', [
'body' => '{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/revisions');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'autosave' => null,
'data' => '',
'dataEncoding' => '',
'description' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'autosave' => null,
'data' => '',
'dataEncoding' => '',
'description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/revisions');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/revisions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/revisions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores/:score/revisions", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/revisions"
payload = {
"autosave": False,
"data": "",
"dataEncoding": "",
"description": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/revisions"
payload <- "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/revisions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores/:score/revisions') do |req|
req.body = "{\n \"autosave\": false,\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"description\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/revisions";
let payload = json!({
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores/:score/revisions \
--header 'content-type: application/json' \
--data '{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}'echo '{
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
}' | \
http POST {{baseUrl}}/scores/:score/revisions \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "autosave": false,\n "data": "",\n "dataEncoding": "",\n "description": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/revisionsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"autosave": false,
"data": "",
"dataEncoding": "",
"description": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/revisions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"autosave": true,
"collaborators": [
"000000000000000000000010",
"000000000000000000000020"
],
"creationDate": "2017-01-26T20:29:10.622000Z",
"description": "New revision",
"user": "000000000000000000000020"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Create a new score
{{baseUrl}}/scores
BODY json
{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores" {:content-type :json
:form-params {:collection ""
:data ""
:dataEncoding ""
:filename ""
:googleDriveFolder ""
:privacy ""
:source {:googleDrive ""}
:title ""}})require "http/client"
url = "{{baseUrl}}/scores"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores"),
Content = new StringContent("{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores"
payload := strings.NewReader("{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 176
{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores")
.setHeader("content-type", "application/json")
.setBody("{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores")
.header("content-type", "application/json")
.body("{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}")
.asString(); const data = JSON.stringify({
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {
googleDrive: ''
},
title: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores',
headers: {'content-type': 'application/json'},
data: {
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {googleDrive: ''},
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"collection":"","data":"","dataEncoding":"","filename":"","googleDriveFolder":"","privacy":"","source":{"googleDrive":""},"title":""}'
};
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}}/scores',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "collection": "",\n "data": "",\n "dataEncoding": "",\n "filename": "",\n "googleDriveFolder": "",\n "privacy": "",\n "source": {\n "googleDrive": ""\n },\n "title": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {googleDrive: ''},
title: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores',
headers: {'content-type': 'application/json'},
body: {
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {googleDrive: ''},
title: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {
googleDrive: ''
},
title: ''
});
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}}/scores',
headers: {'content-type': 'application/json'},
data: {
collection: '',
data: '',
dataEncoding: '',
filename: '',
googleDriveFolder: '',
privacy: '',
source: {googleDrive: ''},
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"collection":"","data":"","dataEncoding":"","filename":"","googleDriveFolder":"","privacy":"","source":{"googleDrive":""},"title":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"collection": @"",
@"data": @"",
@"dataEncoding": @"",
@"filename": @"",
@"googleDriveFolder": @"",
@"privacy": @"",
@"source": @{ @"googleDrive": @"" },
@"title": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'collection' => '',
'data' => '',
'dataEncoding' => '',
'filename' => '',
'googleDriveFolder' => '',
'privacy' => '',
'source' => [
'googleDrive' => ''
],
'title' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores', [
'body' => '{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'collection' => '',
'data' => '',
'dataEncoding' => '',
'filename' => '',
'googleDriveFolder' => '',
'privacy' => '',
'source' => [
'googleDrive' => ''
],
'title' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'collection' => '',
'data' => '',
'dataEncoding' => '',
'filename' => '',
'googleDriveFolder' => '',
'privacy' => '',
'source' => [
'googleDrive' => ''
],
'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores"
payload = {
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": { "googleDrive": "" },
"title": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores"
payload <- "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores') do |req|
req.body = "{\n \"collection\": \"\",\n \"data\": \"\",\n \"dataEncoding\": \"\",\n \"filename\": \"\",\n \"googleDriveFolder\": \"\",\n \"privacy\": \"\",\n \"source\": {\n \"googleDrive\": \"\"\n },\n \"title\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores";
let payload = json!({
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": json!({"googleDrive": ""}),
"title": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores \
--header 'content-type: application/json' \
--data '{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}'echo '{
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": {
"googleDrive": ""
},
"title": ""
}' | \
http POST {{baseUrl}}/scores \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "collection": "",\n "data": "",\n "dataEncoding": "",\n "filename": "",\n "googleDriveFolder": "",\n "privacy": "",\n "source": {\n "googleDrive": ""\n },\n "title": ""\n}' \
--output-document \
- {{baseUrl}}/scoresimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"collection": "",
"data": "",
"dataEncoding": "",
"filename": "",
"googleDriveFolder": "",
"privacy": "",
"source": ["googleDrive": ""],
"title": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a collaborator
{{baseUrl}}/scores/:score/collaborators/:collaborator
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/collaborators/:collaborator");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/scores/:score/collaborators/:collaborator")require "http/client"
url = "{{baseUrl}}/scores/:score/collaborators/:collaborator"
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}}/scores/:score/collaborators/:collaborator"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/collaborators/:collaborator");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/collaborators/:collaborator"
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/scores/:score/collaborators/:collaborator HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/scores/:score/collaborators/:collaborator")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/collaborators/:collaborator"))
.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}}/scores/:score/collaborators/:collaborator")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/scores/:score/collaborators/:collaborator")
.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}}/scores/:score/collaborators/:collaborator');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/scores/:score/collaborators/:collaborator'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/collaborators/:collaborator';
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}}/scores/:score/collaborators/:collaborator',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/collaborators/:collaborator")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/collaborators/:collaborator',
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}}/scores/:score/collaborators/:collaborator'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/scores/:score/collaborators/:collaborator');
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}}/scores/:score/collaborators/:collaborator'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/collaborators/:collaborator';
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}}/scores/:score/collaborators/:collaborator"]
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}}/scores/:score/collaborators/:collaborator" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/collaborators/:collaborator",
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}}/scores/:score/collaborators/:collaborator');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/collaborators/:collaborator');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/collaborators/:collaborator');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/collaborators/:collaborator' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/collaborators/:collaborator' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/scores/:score/collaborators/:collaborator")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/collaborators/:collaborator"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/collaborators/:collaborator"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/collaborators/:collaborator")
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/scores/:score/collaborators/:collaborator') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/collaborators/:collaborator";
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}}/scores/:score/collaborators/:collaboratorhttp DELETE {{baseUrl}}/scores/:score/collaborators/:collaboratorwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/scores/:score/collaborators/:collaboratorimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/collaborators/:collaborator")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a comment
{{baseUrl}}/scores/:score/comments/:comment
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments/:comment");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/scores/:score/comments/:comment")require "http/client"
url = "{{baseUrl}}/scores/:score/comments/:comment"
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}}/scores/:score/comments/:comment"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments/:comment");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments/:comment"
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/scores/:score/comments/:comment HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/scores/:score/comments/:comment")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments/:comment"))
.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}}/scores/:score/comments/:comment")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/scores/:score/comments/:comment")
.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}}/scores/:score/comments/:comment');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/scores/:score/comments/:comment'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments/:comment';
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}}/scores/:score/comments/:comment',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments/:comment")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments/:comment',
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}}/scores/:score/comments/:comment'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/scores/:score/comments/:comment');
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}}/scores/:score/comments/:comment'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments/:comment';
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}}/scores/:score/comments/:comment"]
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}}/scores/:score/comments/:comment" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments/:comment",
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}}/scores/:score/comments/:comment');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments/:comment');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/comments/:comment');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments/:comment' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments/:comment' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/scores/:score/comments/:comment")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments/:comment"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments/:comment"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments/:comment")
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/scores/:score/comments/:comment') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments/:comment";
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}}/scores/:score/comments/:commenthttp DELETE {{baseUrl}}/scores/:score/comments/:commentwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/scores/:score/comments/:commentimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments/:comment")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Delete a score
{{baseUrl}}/scores/:score
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/scores/:score")require "http/client"
url = "{{baseUrl}}/scores/:score"
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}}/scores/:score"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score"
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/scores/:score HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/scores/:score")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score"))
.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}}/scores/:score")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/scores/:score")
.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}}/scores/:score');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/scores/:score'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score';
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}}/scores/:score',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score',
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}}/scores/:score'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/scores/:score');
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}}/scores/:score'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score';
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}}/scores/:score"]
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}}/scores/:score" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score",
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}}/scores/:score');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/scores/:score")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score")
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/scores/:score') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score";
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}}/scores/:scorehttp DELETE {{baseUrl}}/scores/:scorewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/scores/:scoreimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Edit a score's metadata
{{baseUrl}}/scores/:score
BODY json
{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/scores/:score" {:content-type :json
:form-params {:arranger ""
:composer ""
:creationType ""
:description ""
:license ""
:licenseText ""
:lyricist ""
:privacy ""
:sharingKey ""
:subtitle ""
:tags []
:title ""}})require "http/client"
url = "{{baseUrl}}/scores/:score"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/scores/:score"),
Content = new StringContent("{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score"
payload := strings.NewReader("{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/scores/:score HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 221
{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/scores/:score")
.setHeader("content-type", "application/json")
.setBody("{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/scores/:score")
.header("content-type", "application/json")
.body("{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}")
.asString(); const data = JSON.stringify({
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/scores/:score');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score',
headers: {'content-type': 'application/json'},
data: {
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"arranger":"","composer":"","creationType":"","description":"","license":"","licenseText":"","lyricist":"","privacy":"","sharingKey":"","subtitle":"","tags":[],"title":""}'
};
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}}/scores/:score',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "arranger": "",\n "composer": "",\n "creationType": "",\n "description": "",\n "license": "",\n "licenseText": "",\n "lyricist": "",\n "privacy": "",\n "sharingKey": "",\n "subtitle": "",\n "tags": [],\n "title": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score',
headers: {'content-type': 'application/json'},
body: {
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/scores/:score');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
});
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}}/scores/:score',
headers: {'content-type': 'application/json'},
data: {
arranger: '',
composer: '',
creationType: '',
description: '',
license: '',
licenseText: '',
lyricist: '',
privacy: '',
sharingKey: '',
subtitle: '',
tags: [],
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"arranger":"","composer":"","creationType":"","description":"","license":"","licenseText":"","lyricist":"","privacy":"","sharingKey":"","subtitle":"","tags":[],"title":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"arranger": @"",
@"composer": @"",
@"creationType": @"",
@"description": @"",
@"license": @"",
@"licenseText": @"",
@"lyricist": @"",
@"privacy": @"",
@"sharingKey": @"",
@"subtitle": @"",
@"tags": @[ ],
@"title": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'arranger' => '',
'composer' => '',
'creationType' => '',
'description' => '',
'license' => '',
'licenseText' => '',
'lyricist' => '',
'privacy' => '',
'sharingKey' => '',
'subtitle' => '',
'tags' => [
],
'title' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/scores/:score', [
'body' => '{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'arranger' => '',
'composer' => '',
'creationType' => '',
'description' => '',
'license' => '',
'licenseText' => '',
'lyricist' => '',
'privacy' => '',
'sharingKey' => '',
'subtitle' => '',
'tags' => [
],
'title' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'arranger' => '',
'composer' => '',
'creationType' => '',
'description' => '',
'license' => '',
'licenseText' => '',
'lyricist' => '',
'privacy' => '',
'sharingKey' => '',
'subtitle' => '',
'tags' => [
],
'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/scores/:score", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score"
payload = {
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score"
payload <- "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/scores/:score') do |req|
req.body = "{\n \"arranger\": \"\",\n \"composer\": \"\",\n \"creationType\": \"\",\n \"description\": \"\",\n \"license\": \"\",\n \"licenseText\": \"\",\n \"lyricist\": \"\",\n \"privacy\": \"\",\n \"sharingKey\": \"\",\n \"subtitle\": \"\",\n \"tags\": [],\n \"title\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score";
let payload = json!({
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": (),
"title": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/scores/:score \
--header 'content-type: application/json' \
--data '{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}'echo '{
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
}' | \
http PUT {{baseUrl}}/scores/:score \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "arranger": "",\n "composer": "",\n "creationType": "",\n "description": "",\n "license": "",\n "licenseText": "",\n "lyricist": "",\n "privacy": "",\n "sharingKey": "",\n "subtitle": "",\n "tags": [],\n "title": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:scoreimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"arranger": "",
"composer": "",
"creationType": "",
"description": "",
"license": "",
"licenseText": "",
"lyricist": "",
"privacy": "",
"sharingKey": "",
"subtitle": "",
"tags": [],
"title": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Fork a score
{{baseUrl}}/scores/:score/fork
BODY json
{
"collection": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/fork");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"collection\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/fork" {:content-type :json
:form-params {:collection ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/fork"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"collection\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores/:score/fork"),
Content = new StringContent("{\n \"collection\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/fork");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"collection\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/fork"
payload := strings.NewReader("{\n \"collection\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores/:score/fork HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22
{
"collection": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/fork")
.setHeader("content-type", "application/json")
.setBody("{\n \"collection\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/fork"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"collection\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"collection\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/fork")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/fork")
.header("content-type", "application/json")
.body("{\n \"collection\": \"\"\n}")
.asString(); const data = JSON.stringify({
collection: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores/:score/fork');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/fork',
headers: {'content-type': 'application/json'},
data: {collection: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/fork';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"collection":""}'
};
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}}/scores/:score/fork',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "collection": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"collection\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/fork")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/fork',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({collection: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/fork',
headers: {'content-type': 'application/json'},
body: {collection: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/fork');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
collection: ''
});
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}}/scores/:score/fork',
headers: {'content-type': 'application/json'},
data: {collection: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/fork';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"collection":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"collection": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/fork"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/fork" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"collection\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/fork",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'collection' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores/:score/fork', [
'body' => '{
"collection": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/fork');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'collection' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'collection' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/fork');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/fork' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"collection": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/fork' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"collection": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"collection\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores/:score/fork", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/fork"
payload = { "collection": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/fork"
payload <- "{\n \"collection\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/fork")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"collection\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores/:score/fork') do |req|
req.body = "{\n \"collection\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/fork";
let payload = json!({"collection": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores/:score/fork \
--header 'content-type: application/json' \
--data '{
"collection": ""
}'echo '{
"collection": ""
}' | \
http POST {{baseUrl}}/scores/:score/fork \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "collection": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/forkimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["collection": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/fork")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a collaborator
{{baseUrl}}/scores/:score/collaborators/:collaborator
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/collaborators/:collaborator");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/collaborators/:collaborator")require "http/client"
url = "{{baseUrl}}/scores/:score/collaborators/:collaborator"
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}}/scores/:score/collaborators/:collaborator"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/collaborators/:collaborator");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/collaborators/:collaborator"
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/scores/:score/collaborators/:collaborator HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/collaborators/:collaborator")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/collaborators/:collaborator"))
.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}}/scores/:score/collaborators/:collaborator")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/collaborators/:collaborator")
.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}}/scores/:score/collaborators/:collaborator');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/scores/:score/collaborators/:collaborator'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/collaborators/:collaborator';
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}}/scores/:score/collaborators/:collaborator',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/collaborators/:collaborator")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/collaborators/:collaborator',
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}}/scores/:score/collaborators/:collaborator'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/collaborators/:collaborator');
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}}/scores/:score/collaborators/:collaborator'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/collaborators/:collaborator';
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}}/scores/:score/collaborators/:collaborator"]
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}}/scores/:score/collaborators/:collaborator" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/collaborators/:collaborator",
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}}/scores/:score/collaborators/:collaborator');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/collaborators/:collaborator');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/collaborators/:collaborator');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/collaborators/:collaborator' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/collaborators/:collaborator' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/collaborators/:collaborator")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/collaborators/:collaborator"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/collaborators/:collaborator"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/collaborators/:collaborator")
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/scores/:score/collaborators/:collaborator') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/collaborators/:collaborator";
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}}/scores/:score/collaborators/:collaboratorhttp GET {{baseUrl}}/scores/:score/collaborators/:collaboratorwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/collaborators/:collaboratorimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/collaborators/:collaborator")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a score revision data
{{baseUrl}}/scores/:score/revisions/:revision/:format
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/revisions/:revision/:format");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/revisions/:revision/:format")require "http/client"
url = "{{baseUrl}}/scores/:score/revisions/:revision/:format"
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}}/scores/:score/revisions/:revision/:format"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/revisions/:revision/:format");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/revisions/:revision/:format"
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/scores/:score/revisions/:revision/:format HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/revisions/:revision/:format")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/revisions/:revision/:format"))
.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}}/scores/:score/revisions/:revision/:format")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/revisions/:revision/:format")
.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}}/scores/:score/revisions/:revision/:format');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/scores/:score/revisions/:revision/:format'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/revisions/:revision/:format';
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}}/scores/:score/revisions/:revision/:format',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/revisions/:revision/:format")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/revisions/:revision/:format',
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}}/scores/:score/revisions/:revision/:format'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/revisions/:revision/:format');
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}}/scores/:score/revisions/:revision/:format'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/revisions/:revision/:format';
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}}/scores/:score/revisions/:revision/:format"]
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}}/scores/:score/revisions/:revision/:format" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/revisions/:revision/:format",
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}}/scores/:score/revisions/:revision/:format');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/revisions/:revision/:format');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/revisions/:revision/:format');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/revisions/:revision/:format' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/revisions/:revision/:format' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/revisions/:revision/:format")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/revisions/:revision/:format"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/revisions/:revision/:format"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/revisions/:revision/:format")
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/scores/:score/revisions/:revision/:format') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/revisions/:revision/:format";
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}}/scores/:score/revisions/:revision/:formathttp GET {{baseUrl}}/scores/:score/revisions/:revision/:formatwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/revisions/:revision/:formatimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/revisions/:revision/:format")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a score revision
{{baseUrl}}/scores/:score/revisions/:revision
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/revisions/:revision");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/revisions/:revision")require "http/client"
url = "{{baseUrl}}/scores/:score/revisions/:revision"
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}}/scores/:score/revisions/:revision"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/revisions/:revision");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/revisions/:revision"
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/scores/:score/revisions/:revision HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/revisions/:revision")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/revisions/:revision"))
.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}}/scores/:score/revisions/:revision")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/revisions/:revision")
.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}}/scores/:score/revisions/:revision');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/scores/:score/revisions/:revision'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/revisions/:revision';
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}}/scores/:score/revisions/:revision',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/revisions/:revision")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/revisions/:revision',
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}}/scores/:score/revisions/:revision'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/revisions/:revision');
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}}/scores/:score/revisions/:revision'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/revisions/:revision';
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}}/scores/:score/revisions/:revision"]
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}}/scores/:score/revisions/:revision" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/revisions/:revision",
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}}/scores/:score/revisions/:revision');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/revisions/:revision');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/revisions/:revision');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/revisions/:revision' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/revisions/:revision' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/revisions/:revision")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/revisions/:revision"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/revisions/:revision"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/revisions/:revision")
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/scores/:score/revisions/:revision') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/revisions/:revision";
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}}/scores/:score/revisions/:revisionhttp GET {{baseUrl}}/scores/:score/revisions/:revisionwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/revisions/:revisionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/revisions/:revision")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"autosave": true,
"collaborators": [
"000000000000000000000010",
"000000000000000000000020"
],
"creationDate": "2017-01-26T20:29:10.622000Z",
"description": "New revision",
"user": "000000000000000000000020"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a score's metadata
{{baseUrl}}/scores/:score
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score")require "http/client"
url = "{{baseUrl}}/scores/:score"
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}}/scores/:score"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score"
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/scores/:score HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score"))
.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}}/scores/:score")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score")
.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}}/scores/:score');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score';
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}}/scores/:score',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score',
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}}/scores/:score'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score');
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}}/scores/:score'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score';
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}}/scores/:score"]
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}}/scores/:score" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score",
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}}/scores/:score');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score")
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/scores/:score') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score";
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}}/scores/:scorehttp GET {{baseUrl}}/scores/:scorewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:scoreimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List comments
{{baseUrl}}/scores/:score/comments
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/comments")require "http/client"
url = "{{baseUrl}}/scores/:score/comments"
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}}/scores/:score/comments"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments"
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/scores/:score/comments HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/comments")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments"))
.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}}/scores/:score/comments")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/comments")
.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}}/scores/:score/comments');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/comments'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments';
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}}/scores/:score/comments',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments',
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}}/scores/:score/comments'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/comments');
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}}/scores/:score/comments'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments';
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}}/scores/:score/comments"]
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}}/scores/:score/comments" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments",
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}}/scores/:score/comments');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/comments")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments")
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/scores/:score/comments') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments";
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}}/scores/:score/commentshttp GET {{baseUrl}}/scores/:score/commentswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/commentsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"comment": "@[000000000000000000000000:flat] Great work!",
"context": {
"measureUuids": [
"e6a6a60b-8710-f819-9a49-e907b19c6f1f",
"da83d93c-e3a6-3c73-1bbe-15e5131d6437",
"056ec5eb-9213-df56-6ae8-d9b99673dc48"
],
"partUuid": "91982db7-2e6d-285e-7a19-76b4bd005b8b",
"staffUuid": "9395d8f3-f42b-47b6-8c5d-6ba704961ec0",
"startDpq": 1,
"startTimePos": 2,
"stopDpq": 1,
"stopTimePos": 3
},
"date": "2017-01-26T20:29:10.622000Z",
"id": "000000000000000000000010",
"mentions": [
"000000000000000000000000"
],
"modificationDate": "2017-01-26T21:29:10.622000Z",
"rawComment": "@flat: Great work!",
"replyTo": "000000000000000000000000",
"resolved": true,
"resolvedBy": "000000000000000000000000",
"revision": "000000000000000000000011",
"score": "000000000000000000000042",
"spam": false,
"type": "inline",
"user": "000000000000000000000001"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/submissions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/submissions")require "http/client"
url = "{{baseUrl}}/scores/:score/submissions"
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}}/scores/:score/submissions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/submissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/submissions"
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/scores/:score/submissions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/submissions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/submissions"))
.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}}/scores/:score/submissions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/submissions")
.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}}/scores/:score/submissions');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/submissions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/submissions';
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}}/scores/:score/submissions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/submissions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/submissions',
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}}/scores/:score/submissions'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/submissions');
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}}/scores/:score/submissions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/submissions';
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}}/scores/:score/submissions"]
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}}/scores/:score/submissions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/submissions",
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}}/scores/:score/submissions');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/submissions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/submissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/submissions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/submissions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/submissions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/submissions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/submissions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/submissions")
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/scores/:score/submissions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/submissions";
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}}/scores/:score/submissionshttp GET {{baseUrl}}/scores/:score/submissionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/submissionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/submissions")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"assignment": "58c49068524c03ec576ca43c",
"attachments": [
{
"score": "58c4955a226ffff257211a8d",
"title": "Hello - Student",
"type": "flat"
}
],
"classroom": "58c4725345cd836264f0b29e",
"creationDate": "2020-08-12T00:25:00.748000Z",
"creator": "559eb5c7f0d4d5e46d03781d",
"draftGrade": 82,
"googleClassroom": {
"alternateLink": "http://classroom.google.com/c/music-theory/a/first-assignment/submissions/student/my-submission",
"id": "CgsI-00000000000",
"state": "turned_in"
},
"grade": 80,
"id": "58c4955c226ffff257211a90",
"returnCreator": "559eb5c7f0d4d5e46d000000",
"returnDate": "2020-08-15T00:25:00.748000Z",
"submissionDate": "2020-08-12T00:45:22.748000Z"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the audio or video tracks linked to a score
{{baseUrl}}/scores/:score/tracks
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/tracks");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/tracks")require "http/client"
url = "{{baseUrl}}/scores/:score/tracks"
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}}/scores/:score/tracks"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/tracks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/tracks"
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/scores/:score/tracks HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/tracks")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/tracks"))
.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}}/scores/:score/tracks")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/tracks")
.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}}/scores/:score/tracks');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/tracks'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/tracks';
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}}/scores/:score/tracks',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/tracks',
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}}/scores/:score/tracks'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/tracks');
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}}/scores/:score/tracks'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/tracks';
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}}/scores/:score/tracks"]
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}}/scores/:score/tracks" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/tracks",
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}}/scores/:score/tracks');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/tracks');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/tracks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/tracks' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/tracks' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/tracks")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/tracks"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/tracks"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/tracks")
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/scores/:score/tracks') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/tracks";
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}}/scores/:score/trackshttp GET {{baseUrl}}/scores/:score/trackswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/tracksimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/tracks")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"creationDate": "2017-10-22T14:58:22.753000Z",
"creator": "5815d4b53269d90d2c80b71c",
"default": true,
"id": "59ecb20e563736b1e1f75dce",
"mediaId": "dQw4w9WgXcQ",
"modificationDate": "2017-10-22T14:58:33.424000Z",
"score": "59a29d96f35a6411d7508bdd",
"state": "completed",
"synchronizationPoints": [
{
"measureUuid": "5132a788-69e6-d0c6-84ec-4bd858658d7c",
"time": 0,
"type": "measure"
},
{
"time": 213,
"type": "end"
}
],
"title": "Rick Astley - Never Gonna Give You Up",
"type": "youtube",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the collaborators
{{baseUrl}}/scores/:score/collaborators
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/collaborators");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/collaborators")require "http/client"
url = "{{baseUrl}}/scores/:score/collaborators"
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}}/scores/:score/collaborators"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/collaborators");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/collaborators"
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/scores/:score/collaborators HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/collaborators")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/collaborators"))
.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}}/scores/:score/collaborators")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/collaborators")
.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}}/scores/:score/collaborators');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/collaborators'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/collaborators';
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}}/scores/:score/collaborators',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/collaborators")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/collaborators',
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}}/scores/:score/collaborators'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/collaborators');
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}}/scores/:score/collaborators'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/collaborators';
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}}/scores/:score/collaborators"]
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}}/scores/:score/collaborators" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/collaborators",
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}}/scores/:score/collaborators');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/collaborators');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/collaborators');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/collaborators' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/collaborators' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/collaborators")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/collaborators"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/collaborators"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/collaborators")
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/scores/:score/collaborators') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/collaborators";
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}}/scores/:score/collaboratorshttp GET {{baseUrl}}/scores/:score/collaboratorswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/collaboratorsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/collaborators")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List the revisions
{{baseUrl}}/scores/:score/revisions
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/revisions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/revisions")require "http/client"
url = "{{baseUrl}}/scores/:score/revisions"
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}}/scores/:score/revisions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/revisions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/revisions"
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/scores/:score/revisions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/revisions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/revisions"))
.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}}/scores/:score/revisions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/revisions")
.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}}/scores/:score/revisions');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/revisions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/revisions';
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}}/scores/:score/revisions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/revisions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/revisions',
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}}/scores/:score/revisions'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/revisions');
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}}/scores/:score/revisions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/revisions';
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}}/scores/:score/revisions"]
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}}/scores/:score/revisions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/revisions",
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}}/scores/:score/revisions');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/revisions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/revisions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/revisions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/revisions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/revisions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/revisions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/revisions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/revisions")
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/scores/:score/revisions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/revisions";
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}}/scores/:score/revisionshttp GET {{baseUrl}}/scores/:score/revisionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/revisionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/revisions")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"autosave": true,
"collaborators": [
"000000000000000000000010",
"000000000000000000000020"
],
"creationDate": "2017-01-26T20:29:10.622000Z",
"description": "New revision",
"user": "000000000000000000000020"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Mark the comment as resolved
{{baseUrl}}/scores/:score/comments/:comment/resolved
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments/:comment/resolved");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/scores/:score/comments/:comment/resolved")require "http/client"
url = "{{baseUrl}}/scores/:score/comments/:comment/resolved"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/scores/:score/comments/:comment/resolved"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments/:comment/resolved");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments/:comment/resolved"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/scores/:score/comments/:comment/resolved HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/scores/:score/comments/:comment/resolved")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments/:comment/resolved"))
.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}}/scores/:score/comments/:comment/resolved")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/scores/:score/comments/:comment/resolved")
.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}}/scores/:score/comments/:comment/resolved');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score/comments/:comment/resolved'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments/:comment/resolved';
const options = {method: 'PUT'};
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}}/scores/:score/comments/:comment/resolved',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments/:comment/resolved")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments/:comment/resolved',
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: 'PUT',
url: '{{baseUrl}}/scores/:score/comments/:comment/resolved'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/scores/:score/comments/:comment/resolved');
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}}/scores/:score/comments/:comment/resolved'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments/:comment/resolved';
const options = {method: 'PUT'};
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}}/scores/:score/comments/:comment/resolved"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
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}}/scores/:score/comments/:comment/resolved" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments/:comment/resolved",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/scores/:score/comments/:comment/resolved');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments/:comment/resolved');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/comments/:comment/resolved');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments/:comment/resolved' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments/:comment/resolved' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/scores/:score/comments/:comment/resolved")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments/:comment/resolved"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments/:comment/resolved"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments/:comment/resolved")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/scores/:score/comments/:comment/resolved') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments/:comment/resolved";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/scores/:score/comments/:comment/resolvedhttp PUT {{baseUrl}}/scores/:score/comments/:comment/resolvedwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/scores/:score/comments/:comment/resolvedimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments/:comment/resolved")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Mark the comment as unresolved
{{baseUrl}}/scores/:score/comments/:comment/resolved
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments/:comment/resolved");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/scores/:score/comments/:comment/resolved")require "http/client"
url = "{{baseUrl}}/scores/:score/comments/:comment/resolved"
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}}/scores/:score/comments/:comment/resolved"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments/:comment/resolved");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments/:comment/resolved"
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/scores/:score/comments/:comment/resolved HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/scores/:score/comments/:comment/resolved")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments/:comment/resolved"))
.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}}/scores/:score/comments/:comment/resolved")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/scores/:score/comments/:comment/resolved")
.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}}/scores/:score/comments/:comment/resolved');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/scores/:score/comments/:comment/resolved'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments/:comment/resolved';
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}}/scores/:score/comments/:comment/resolved',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments/:comment/resolved")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments/:comment/resolved',
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}}/scores/:score/comments/:comment/resolved'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/scores/:score/comments/:comment/resolved');
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}}/scores/:score/comments/:comment/resolved'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments/:comment/resolved';
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}}/scores/:score/comments/:comment/resolved"]
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}}/scores/:score/comments/:comment/resolved" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments/:comment/resolved",
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}}/scores/:score/comments/:comment/resolved');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments/:comment/resolved');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/comments/:comment/resolved');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments/:comment/resolved' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments/:comment/resolved' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/scores/:score/comments/:comment/resolved")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments/:comment/resolved"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments/:comment/resolved"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments/:comment/resolved")
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/scores/:score/comments/:comment/resolved') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments/:comment/resolved";
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}}/scores/:score/comments/:comment/resolvedhttp DELETE {{baseUrl}}/scores/:score/comments/:comment/resolvedwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/scores/:score/comments/:comment/resolvedimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments/:comment/resolved")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Post a new comment
{{baseUrl}}/scores/:score/comments
BODY json
{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/comments" {:content-type :json
:form-params {:comment ""
:context {:measureUuids []
:partUuid ""
:staffIdx ""
:staffUuid ""
:startDpq ""
:startTimePos ""
:stopDpq ""
:stopTimePos ""}
:mentions []
:rawComment ""
:replyTo ""
:revision ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/comments"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/scores/:score/comments"),
Content = new StringContent("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments"
payload := strings.NewReader("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/scores/:score/comments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 282
{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/comments")
.setHeader("content-type", "application/json")
.setBody("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/comments")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/comments")
.header("content-type", "application/json")
.body("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}")
.asString(); const data = JSON.stringify({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/scores/:score/comments');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/comments',
headers: {'content-type': 'application/json'},
data: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"comment":"","context":{"measureUuids":[],"partUuid":"","staffIdx":"","staffUuid":"","startDpq":"","startTimePos":"","stopDpq":"","stopTimePos":""},"mentions":[],"rawComment":"","replyTo":"","revision":""}'
};
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}}/scores/:score/comments',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "comment": "",\n "context": {\n "measureUuids": [],\n "partUuid": "",\n "staffIdx": "",\n "staffUuid": "",\n "startDpq": "",\n "startTimePos": "",\n "stopDpq": "",\n "stopTimePos": ""\n },\n "mentions": [],\n "rawComment": "",\n "replyTo": "",\n "revision": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/scores/:score/comments',
headers: {'content-type': 'application/json'},
body: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/comments');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
});
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}}/scores/:score/comments',
headers: {'content-type': 'application/json'},
data: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
mentions: [],
rawComment: '',
replyTo: '',
revision: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"comment":"","context":{"measureUuids":[],"partUuid":"","staffIdx":"","staffUuid":"","startDpq":"","startTimePos":"","stopDpq":"","stopTimePos":""},"mentions":[],"rawComment":"","replyTo":"","revision":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"comment": @"",
@"context": @{ @"measureUuids": @[ ], @"partUuid": @"", @"staffIdx": @"", @"staffUuid": @"", @"startDpq": @"", @"startTimePos": @"", @"stopDpq": @"", @"stopTimePos": @"" },
@"mentions": @[ ],
@"rawComment": @"",
@"replyTo": @"",
@"revision": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/comments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/comments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'mentions' => [
],
'rawComment' => '',
'replyTo' => '',
'revision' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/scores/:score/comments', [
'body' => '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'mentions' => [
],
'rawComment' => '',
'replyTo' => '',
'revision' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'mentions' => [
],
'rawComment' => '',
'replyTo' => '',
'revision' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/comments');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/scores/:score/comments", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments"
payload = {
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments"
payload <- "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/scores/:score/comments') do |req|
req.body = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"mentions\": [],\n \"rawComment\": \"\",\n \"replyTo\": \"\",\n \"revision\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments";
let payload = json!({
"comment": "",
"context": json!({
"measureUuids": (),
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
}),
"mentions": (),
"rawComment": "",
"replyTo": "",
"revision": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scores/:score/comments \
--header 'content-type: application/json' \
--data '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}'echo '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
}' | \
http POST {{baseUrl}}/scores/:score/comments \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "comment": "",\n "context": {\n "measureUuids": [],\n "partUuid": "",\n "staffIdx": "",\n "staffUuid": "",\n "startDpq": "",\n "startTimePos": "",\n "stopDpq": "",\n "stopTimePos": ""\n },\n "mentions": [],\n "rawComment": "",\n "replyTo": "",\n "revision": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/commentsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"comment": "",
"context": [
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
],
"mentions": [],
"rawComment": "",
"replyTo": "",
"revision": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"comment": "@[000000000000000000000000:flat] Great work!",
"context": {
"measureUuids": [
"e6a6a60b-8710-f819-9a49-e907b19c6f1f",
"da83d93c-e3a6-3c73-1bbe-15e5131d6437",
"056ec5eb-9213-df56-6ae8-d9b99673dc48"
],
"partUuid": "91982db7-2e6d-285e-7a19-76b4bd005b8b",
"staffUuid": "9395d8f3-f42b-47b6-8c5d-6ba704961ec0",
"startDpq": 1,
"startTimePos": 2,
"stopDpq": 1,
"stopTimePos": 3
},
"date": "2017-01-26T20:29:10.622000Z",
"id": "000000000000000000000010",
"mentions": [
"000000000000000000000000"
],
"modificationDate": "2017-01-26T21:29:10.622000Z",
"rawComment": "@flat: Great work!",
"replyTo": "000000000000000000000000",
"resolved": true,
"resolvedBy": "000000000000000000000000",
"revision": "000000000000000000000011",
"score": "000000000000000000000042",
"spam": false,
"type": "inline",
"user": "000000000000000000000001"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
DELETE
Remove an audio or video track linked to the score
{{baseUrl}}/scores/:score/tracks/:track
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/tracks/:track");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/scores/:score/tracks/:track")require "http/client"
url = "{{baseUrl}}/scores/:score/tracks/:track"
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}}/scores/:score/tracks/:track"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/tracks/:track");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/tracks/:track"
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/scores/:score/tracks/:track HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/scores/:score/tracks/:track")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/tracks/:track"))
.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}}/scores/:score/tracks/:track")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/scores/:score/tracks/:track")
.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}}/scores/:score/tracks/:track');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/scores/:score/tracks/:track'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/tracks/:track';
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}}/scores/:score/tracks/:track',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks/:track")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/tracks/:track',
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}}/scores/:score/tracks/:track'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/scores/:score/tracks/:track');
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}}/scores/:score/tracks/:track'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/tracks/:track';
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}}/scores/:score/tracks/:track"]
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}}/scores/:score/tracks/:track" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/tracks/:track",
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}}/scores/:score/tracks/:track');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/scores/:score/tracks/:track")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/tracks/:track"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/tracks/:track"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/tracks/:track")
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/scores/:score/tracks/:track') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/tracks/:track";
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}}/scores/:score/tracks/:trackhttp DELETE {{baseUrl}}/scores/:score/tracks/:trackwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/scores/:score/tracks/:trackimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/tracks/:track")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Retrieve the details of an audio or video track linked to a score
{{baseUrl}}/scores/:score/tracks/:track
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/tracks/:track");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/scores/:score/tracks/:track")require "http/client"
url = "{{baseUrl}}/scores/:score/tracks/:track"
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}}/scores/:score/tracks/:track"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/tracks/:track");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/tracks/:track"
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/scores/:score/tracks/:track HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/scores/:score/tracks/:track")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/tracks/:track"))
.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}}/scores/:score/tracks/:track")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/scores/:score/tracks/:track")
.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}}/scores/:score/tracks/:track');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/scores/:score/tracks/:track'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/tracks/:track';
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}}/scores/:score/tracks/:track',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks/:track")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/tracks/:track',
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}}/scores/:score/tracks/:track'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/scores/:score/tracks/:track');
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}}/scores/:score/tracks/:track'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/tracks/:track';
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}}/scores/:score/tracks/:track"]
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}}/scores/:score/tracks/:track" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/tracks/:track",
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}}/scores/:score/tracks/:track');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/scores/:score/tracks/:track")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/tracks/:track"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/tracks/:track"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/tracks/:track")
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/scores/:score/tracks/:track') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/tracks/:track";
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}}/scores/:score/tracks/:trackhttp GET {{baseUrl}}/scores/:score/tracks/:trackwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/scores/:score/tracks/:trackimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/tracks/:track")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"creationDate": "2017-10-22T14:58:22.753000Z",
"creator": "5815d4b53269d90d2c80b71c",
"default": true,
"id": "59ecb20e563736b1e1f75dce",
"mediaId": "dQw4w9WgXcQ",
"modificationDate": "2017-10-22T14:58:33.424000Z",
"score": "59a29d96f35a6411d7508bdd",
"state": "completed",
"synchronizationPoints": [
{
"measureUuid": "5132a788-69e6-d0c6-84ec-4bd858658d7c",
"time": 0,
"type": "measure"
},
{
"time": 213,
"type": "end"
}
],
"title": "Rick Astley - Never Gonna Give You Up",
"type": "youtube",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
POST
Untrash a score
{{baseUrl}}/scores/:score/untrash
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/untrash");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/scores/:score/untrash")require "http/client"
url = "{{baseUrl}}/scores/:score/untrash"
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}}/scores/:score/untrash"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/untrash");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/untrash"
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/scores/:score/untrash HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/scores/:score/untrash")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/untrash"))
.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}}/scores/:score/untrash")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/scores/:score/untrash")
.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}}/scores/:score/untrash');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/scores/:score/untrash'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/untrash';
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}}/scores/:score/untrash',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/untrash")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/untrash',
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}}/scores/:score/untrash'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/scores/:score/untrash');
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}}/scores/:score/untrash'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/untrash';
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}}/scores/:score/untrash"]
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}}/scores/:score/untrash" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/untrash",
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}}/scores/:score/untrash');
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/untrash');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/scores/:score/untrash');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/untrash' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/untrash' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/scores/:score/untrash")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/untrash"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/untrash"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/untrash")
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/scores/:score/untrash') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/untrash";
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}}/scores/:score/untrashhttp POST {{baseUrl}}/scores/:score/untrashwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/scores/:score/untrashimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/untrash")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update an audio or video track linked to a score
{{baseUrl}}/scores/:score/tracks/:track
BODY json
{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/tracks/:track");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/scores/:score/tracks/:track" {:content-type :json
:form-params {:default false
:state ""
:synchronizationPoints [{:measureUuid ""
:time ""
:type ""}]
:title ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/tracks/:track"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/scores/:score/tracks/:track"),
Content = new StringContent("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/tracks/:track");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/tracks/:track"
payload := strings.NewReader("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/scores/:score/tracks/:track HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 158
{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/scores/:score/tracks/:track")
.setHeader("content-type", "application/json")
.setBody("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/tracks/:track"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks/:track")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/scores/:score/tracks/:track")
.header("content-type", "application/json")
.body("{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}")
.asString(); const data = JSON.stringify({
default: false,
state: '',
synchronizationPoints: [
{
measureUuid: '',
time: '',
type: ''
}
],
title: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/scores/:score/tracks/:track');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score/tracks/:track',
headers: {'content-type': 'application/json'},
data: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/tracks/:track';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"default":false,"state":"","synchronizationPoints":[{"measureUuid":"","time":"","type":""}],"title":""}'
};
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}}/scores/:score/tracks/:track',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "default": false,\n "state": "",\n "synchronizationPoints": [\n {\n "measureUuid": "",\n "time": "",\n "type": ""\n }\n ],\n "title": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/tracks/:track")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/tracks/:track',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: ''
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score/tracks/:track',
headers: {'content-type': 'application/json'},
body: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/scores/:score/tracks/:track');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
default: false,
state: '',
synchronizationPoints: [
{
measureUuid: '',
time: '',
type: ''
}
],
title: ''
});
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}}/scores/:score/tracks/:track',
headers: {'content-type': 'application/json'},
data: {
default: false,
state: '',
synchronizationPoints: [{measureUuid: '', time: '', type: ''}],
title: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/tracks/:track';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"default":false,"state":"","synchronizationPoints":[{"measureUuid":"","time":"","type":""}],"title":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"default": @NO,
@"state": @"",
@"synchronizationPoints": @[ @{ @"measureUuid": @"", @"time": @"", @"type": @"" } ],
@"title": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/tracks/:track"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/tracks/:track" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/tracks/:track",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/scores/:score/tracks/:track', [
'body' => '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'default' => null,
'state' => '',
'synchronizationPoints' => [
[
'measureUuid' => '',
'time' => '',
'type' => ''
]
],
'title' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/tracks/:track');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/tracks/:track' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/scores/:score/tracks/:track", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/tracks/:track"
payload = {
"default": False,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/tracks/:track"
payload <- "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/tracks/:track")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/scores/:score/tracks/:track') do |req|
req.body = "{\n \"default\": false,\n \"state\": \"\",\n \"synchronizationPoints\": [\n {\n \"measureUuid\": \"\",\n \"time\": \"\",\n \"type\": \"\"\n }\n ],\n \"title\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/tracks/:track";
let payload = json!({
"default": false,
"state": "",
"synchronizationPoints": (
json!({
"measureUuid": "",
"time": "",
"type": ""
})
),
"title": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/scores/:score/tracks/:track \
--header 'content-type: application/json' \
--data '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}'echo '{
"default": false,
"state": "",
"synchronizationPoints": [
{
"measureUuid": "",
"time": "",
"type": ""
}
],
"title": ""
}' | \
http PUT {{baseUrl}}/scores/:score/tracks/:track \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "default": false,\n "state": "",\n "synchronizationPoints": [\n {\n "measureUuid": "",\n "time": "",\n "type": ""\n }\n ],\n "title": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/tracks/:trackimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"default": false,
"state": "",
"synchronizationPoints": [
[
"measureUuid": "",
"time": "",
"type": ""
]
],
"title": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/tracks/:track")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"creationDate": "2017-10-22T14:58:22.753000Z",
"creator": "5815d4b53269d90d2c80b71c",
"default": true,
"id": "59ecb20e563736b1e1f75dce",
"mediaId": "dQw4w9WgXcQ",
"modificationDate": "2017-10-22T14:58:33.424000Z",
"score": "59a29d96f35a6411d7508bdd",
"state": "completed",
"synchronizationPoints": [
{
"measureUuid": "5132a788-69e6-d0c6-84ec-4bd858658d7c",
"time": 0,
"type": "measure"
},
{
"time": 213,
"type": "end"
}
],
"title": "Rick Astley - Never Gonna Give You Up",
"type": "youtube",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
PUT
Update an existing comment
{{baseUrl}}/scores/:score/comments/:comment
BODY json
{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/scores/:score/comments/:comment");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/scores/:score/comments/:comment" {:content-type :json
:form-params {:comment ""
:context {:measureUuids []
:partUuid ""
:staffIdx ""
:staffUuid ""
:startDpq ""
:startTimePos ""
:stopDpq ""
:stopTimePos ""}
:rawComment ""
:revision ""}})require "http/client"
url = "{{baseUrl}}/scores/:score/comments/:comment"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/scores/:score/comments/:comment"),
Content = new StringContent("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/scores/:score/comments/:comment");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/scores/:score/comments/:comment"
payload := strings.NewReader("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/scores/:score/comments/:comment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 247
{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/scores/:score/comments/:comment")
.setHeader("content-type", "application/json")
.setBody("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/scores/:score/comments/:comment"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/scores/:score/comments/:comment")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/scores/:score/comments/:comment")
.header("content-type", "application/json")
.body("{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}")
.asString(); const data = JSON.stringify({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/scores/:score/comments/:comment');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score/comments/:comment',
headers: {'content-type': 'application/json'},
data: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/scores/:score/comments/:comment';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"comment":"","context":{"measureUuids":[],"partUuid":"","staffIdx":"","staffUuid":"","startDpq":"","startTimePos":"","stopDpq":"","stopTimePos":""},"rawComment":"","revision":""}'
};
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}}/scores/:score/comments/:comment',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "comment": "",\n "context": {\n "measureUuids": [],\n "partUuid": "",\n "staffIdx": "",\n "staffUuid": "",\n "startDpq": "",\n "startTimePos": "",\n "stopDpq": "",\n "stopTimePos": ""\n },\n "rawComment": "",\n "revision": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/scores/:score/comments/:comment")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/scores/:score/comments/:comment',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/scores/:score/comments/:comment',
headers: {'content-type': 'application/json'},
body: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/scores/:score/comments/:comment');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
});
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}}/scores/:score/comments/:comment',
headers: {'content-type': 'application/json'},
data: {
comment: '',
context: {
measureUuids: [],
partUuid: '',
staffIdx: '',
staffUuid: '',
startDpq: '',
startTimePos: '',
stopDpq: '',
stopTimePos: ''
},
rawComment: '',
revision: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/scores/:score/comments/:comment';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"comment":"","context":{"measureUuids":[],"partUuid":"","staffIdx":"","staffUuid":"","startDpq":"","startTimePos":"","stopDpq":"","stopTimePos":""},"rawComment":"","revision":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"comment": @"",
@"context": @{ @"measureUuids": @[ ], @"partUuid": @"", @"staffIdx": @"", @"staffUuid": @"", @"startDpq": @"", @"startTimePos": @"", @"stopDpq": @"", @"stopTimePos": @"" },
@"rawComment": @"",
@"revision": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/scores/:score/comments/:comment"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/scores/:score/comments/:comment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/scores/:score/comments/:comment",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'rawComment' => '',
'revision' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/scores/:score/comments/:comment', [
'body' => '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/scores/:score/comments/:comment');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'rawComment' => '',
'revision' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'comment' => '',
'context' => [
'measureUuids' => [
],
'partUuid' => '',
'staffIdx' => '',
'staffUuid' => '',
'startDpq' => '',
'startTimePos' => '',
'stopDpq' => '',
'stopTimePos' => ''
],
'rawComment' => '',
'revision' => ''
]));
$request->setRequestUrl('{{baseUrl}}/scores/:score/comments/:comment');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/scores/:score/comments/:comment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/scores/:score/comments/:comment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/scores/:score/comments/:comment", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/scores/:score/comments/:comment"
payload = {
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/scores/:score/comments/:comment"
payload <- "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/scores/:score/comments/:comment")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/scores/:score/comments/:comment') do |req|
req.body = "{\n \"comment\": \"\",\n \"context\": {\n \"measureUuids\": [],\n \"partUuid\": \"\",\n \"staffIdx\": \"\",\n \"staffUuid\": \"\",\n \"startDpq\": \"\",\n \"startTimePos\": \"\",\n \"stopDpq\": \"\",\n \"stopTimePos\": \"\"\n },\n \"rawComment\": \"\",\n \"revision\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/scores/:score/comments/:comment";
let payload = json!({
"comment": "",
"context": json!({
"measureUuids": (),
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
}),
"rawComment": "",
"revision": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/scores/:score/comments/:comment \
--header 'content-type: application/json' \
--data '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}'echo '{
"comment": "",
"context": {
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
},
"rawComment": "",
"revision": ""
}' | \
http PUT {{baseUrl}}/scores/:score/comments/:comment \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "comment": "",\n "context": {\n "measureUuids": [],\n "partUuid": "",\n "staffIdx": "",\n "staffUuid": "",\n "startDpq": "",\n "startTimePos": "",\n "stopDpq": "",\n "stopTimePos": ""\n },\n "rawComment": "",\n "revision": ""\n}' \
--output-document \
- {{baseUrl}}/scores/:score/comments/:commentimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"comment": "",
"context": [
"measureUuids": [],
"partUuid": "",
"staffIdx": "",
"staffUuid": "",
"startDpq": "",
"startTimePos": "",
"stopDpq": "",
"stopTimePos": ""
],
"rawComment": "",
"revision": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/scores/:score/comments/:comment")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"comment": "@[000000000000000000000000:flat] Great work!",
"context": {
"measureUuids": [
"e6a6a60b-8710-f819-9a49-e907b19c6f1f",
"da83d93c-e3a6-3c73-1bbe-15e5131d6437",
"056ec5eb-9213-df56-6ae8-d9b99673dc48"
],
"partUuid": "91982db7-2e6d-285e-7a19-76b4bd005b8b",
"staffUuid": "9395d8f3-f42b-47b6-8c5d-6ba704961ec0",
"startDpq": 1,
"startTimePos": 2,
"stopDpq": 1,
"stopTimePos": 3
},
"date": "2017-01-26T20:29:10.622000Z",
"id": "000000000000000000000010",
"mentions": [
"000000000000000000000000"
],
"modificationDate": "2017-01-26T21:29:10.622000Z",
"rawComment": "@flat: Great work!",
"replyTo": "000000000000000000000000",
"resolved": true,
"resolvedBy": "000000000000000000000000",
"revision": "000000000000000000000011",
"score": "000000000000000000000042",
"spam": false,
"type": "inline",
"user": "000000000000000000000001"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
Get a public user profile
{{baseUrl}}/users/:user
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user")require "http/client"
url = "{{baseUrl}}/users/:user"
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}}/users/:user"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user"
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/users/:user HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user"))
.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}}/users/:user")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user")
.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}}/users/:user');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user';
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}}/users/:user',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user',
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}}/users/:user'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user');
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}}/users/:user'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user';
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}}/users/:user"]
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}}/users/:user" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user",
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}}/users/:user');
echo $response->getBody();setUrl('{{baseUrl}}/users/:user');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users/:user")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user")
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/users/:user') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user";
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}}/users/:userhttp GET {{baseUrl}}/users/:userwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/users/:userimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List liked scores
{{baseUrl}}/users/:user/likes
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user/likes");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user/likes")require "http/client"
url = "{{baseUrl}}/users/:user/likes"
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}}/users/:user/likes"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user/likes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user/likes"
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/users/:user/likes HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user/likes")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user/likes"))
.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}}/users/:user/likes")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user/likes")
.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}}/users/:user/likes');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users/:user/likes'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user/likes';
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}}/users/:user/likes',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user/likes")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user/likes',
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}}/users/:user/likes'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user/likes');
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}}/users/:user/likes'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user/likes';
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}}/users/:user/likes"]
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}}/users/:user/likes" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user/likes",
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}}/users/:user/likes');
echo $response->getBody();setUrl('{{baseUrl}}/users/:user/likes');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user/likes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user/likes' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user/likes' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users/:user/likes")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user/likes"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user/likes"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user/likes")
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/users/:user/likes') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user/likes";
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}}/users/:user/likeshttp GET {{baseUrl}}/users/:user/likeswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/users/:user/likesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user/likes")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}
GET
List user's scores
{{baseUrl}}/users/:user/scores
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user/scores");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user/scores")require "http/client"
url = "{{baseUrl}}/users/:user/scores"
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}}/users/:user/scores"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user/scores");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user/scores"
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/users/:user/scores HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user/scores")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user/scores"))
.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}}/users/:user/scores")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user/scores")
.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}}/users/:user/scores');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users/:user/scores'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user/scores';
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}}/users/:user/scores',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user/scores")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user/scores',
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}}/users/:user/scores'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user/scores');
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}}/users/:user/scores'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user/scores';
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}}/users/:user/scores"]
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}}/users/:user/scores" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user/scores",
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}}/users/:user/scores');
echo $response->getBody();setUrl('{{baseUrl}}/users/:user/scores');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user/scores');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user/scores' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user/scores' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users/:user/scores")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user/scores"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user/scores"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user/scores")
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/users/:user/scores') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user/scores";
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}}/users/:user/scoreshttp GET {{baseUrl}}/users/:user/scoreswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/users/:user/scoresimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user/scores")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": "CLIENT_ERROR",
"id": "123456789",
"message": "Invalid request"
}