Flat API
Flat APIv2.13.0
The Flat API allows you to easily extend the abilities of the Flat Platform, with a wide range of use cases including the following: Creating and importing new music scores using MusicXML, MIDI, Guitar Pro (GP3, GP4, GP5, GPX, GP), PowerTab, TuxGuitar and MuseScore files Browsing, updating, copying, exporting the user's scores (for example in MP3, WAV or MIDI) Managing educational resources with Flat for Education: creating & updating the organization accounts, the classes, rosters and assignments. The Flat API is built on HTTP. Our API is RESTful It has predictable resource URLs. It returns…
- Endpoints
- 81 (34 GET, 20 POST, 15 DELETE, 12 PUT)
- Base URL
https://api.flat.io/v2- Authentication
- OAuth 2.0
- Spec format
- OpenAPI 3.0.2
- API version
- 2.13.0
- Provider
- flat.io
- Categories
- Media, Collaboration
- Last updated
Use this API in Bruno:
- Download the Bruno collection above and unzip it.
- In Bruno, choose Open Collection and select the unzipped folder.
- Set the
baseUrlvariable (for examplehttps://api.flat.io/v2) and your OAuth 2.0 credentials, then send requests.
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"
}