AmplifyBackend
POST
CloneBackend
{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"targetEnvironmentName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone");
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 \"targetEnvironmentName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone" {:content-type :json
:form-params {:targetEnvironmentName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"targetEnvironmentName\": \"\"\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}}/backend/:appId/environments/:backendEnvironmentName/clone"),
Content = new StringContent("{\n \"targetEnvironmentName\": \"\"\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}}/backend/:appId/environments/:backendEnvironmentName/clone");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"targetEnvironmentName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"
payload := strings.NewReader("{\n \"targetEnvironmentName\": \"\"\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/backend/:appId/environments/:backendEnvironmentName/clone HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33
{
"targetEnvironmentName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone")
.setHeader("content-type", "application/json")
.setBody("{\n \"targetEnvironmentName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"targetEnvironmentName\": \"\"\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 \"targetEnvironmentName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone")
.header("content-type", "application/json")
.body("{\n \"targetEnvironmentName\": \"\"\n}")
.asString(); const data = JSON.stringify({
targetEnvironmentName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone',
headers: {'content-type': 'application/json'},
data: {targetEnvironmentName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"targetEnvironmentName":""}'
};
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}}/backend/:appId/environments/:backendEnvironmentName/clone',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "targetEnvironmentName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"targetEnvironmentName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone")
.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/backend/:appId/environments/:backendEnvironmentName/clone',
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({targetEnvironmentName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone',
headers: {'content-type': 'application/json'},
body: {targetEnvironmentName: ''},
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}}/backend/:appId/environments/:backendEnvironmentName/clone');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
targetEnvironmentName: ''
});
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}}/backend/:appId/environments/:backendEnvironmentName/clone',
headers: {'content-type': 'application/json'},
data: {targetEnvironmentName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"targetEnvironmentName":""}'
};
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 = @{ @"targetEnvironmentName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"]
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}}/backend/:appId/environments/:backendEnvironmentName/clone" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"targetEnvironmentName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone",
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([
'targetEnvironmentName' => ''
]),
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}}/backend/:appId/environments/:backendEnvironmentName/clone', [
'body' => '{
"targetEnvironmentName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'targetEnvironmentName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'targetEnvironmentName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone');
$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}}/backend/:appId/environments/:backendEnvironmentName/clone' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"targetEnvironmentName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"targetEnvironmentName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"targetEnvironmentName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/environments/:backendEnvironmentName/clone", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"
payload = { "targetEnvironmentName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone"
payload <- "{\n \"targetEnvironmentName\": \"\"\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}}/backend/:appId/environments/:backendEnvironmentName/clone")
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 \"targetEnvironmentName\": \"\"\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/backend/:appId/environments/:backendEnvironmentName/clone') do |req|
req.body = "{\n \"targetEnvironmentName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone";
let payload = json!({"targetEnvironmentName": ""});
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}}/backend/:appId/environments/:backendEnvironmentName/clone \
--header 'content-type: application/json' \
--data '{
"targetEnvironmentName": ""
}'echo '{
"targetEnvironmentName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "targetEnvironmentName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/cloneimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["targetEnvironmentName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/clone")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateBackend
{{baseUrl}}/backend
BODY json
{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend");
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 \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend" {:content-type :json
:form-params {:appId ""
:appName ""
:backendEnvironmentName ""
:resourceConfig {}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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}}/backend"),
Content = new StringContent("{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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}}/backend");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend"
payload := strings.NewReader("{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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/backend HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112
{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend")
.setHeader("content-type", "application/json")
.setBody("{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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 \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend")
.header("content-type", "application/json")
.body("{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend',
headers: {'content-type': 'application/json'},
data: {
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"appId":"","appName":"","backendEnvironmentName":"","resourceConfig":{},"resourceName":""}'
};
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}}/backend',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "appId": "",\n "appName": "",\n "backendEnvironmentName": "",\n "resourceConfig": {},\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend")
.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/backend',
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({
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend',
headers: {'content-type': 'application/json'},
body: {
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
},
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}}/backend');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
});
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}}/backend',
headers: {'content-type': 'application/json'},
data: {
appId: '',
appName: '',
backendEnvironmentName: '',
resourceConfig: {},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"appId":"","appName":"","backendEnvironmentName":"","resourceConfig":{},"resourceName":""}'
};
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 = @{ @"appId": @"",
@"appName": @"",
@"backendEnvironmentName": @"",
@"resourceConfig": @{ },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend"]
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}}/backend" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend",
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([
'appId' => '',
'appName' => '',
'backendEnvironmentName' => '',
'resourceConfig' => [
],
'resourceName' => ''
]),
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}}/backend', [
'body' => '{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'appId' => '',
'appName' => '',
'backendEnvironmentName' => '',
'resourceConfig' => [
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'appId' => '',
'appName' => '',
'backendEnvironmentName' => '',
'resourceConfig' => [
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend');
$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}}/backend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend"
payload = {
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend"
payload <- "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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}}/backend")
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 \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\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/backend') do |req|
req.body = "{\n \"appId\": \"\",\n \"appName\": \"\",\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {},\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend";
let payload = json!({
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": json!({}),
"resourceName": ""
});
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}}/backend \
--header 'content-type: application/json' \
--data '{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}'echo '{
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": {},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "appId": "",\n "appName": "",\n "backendEnvironmentName": "",\n "resourceConfig": {},\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backendimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"appId": "",
"appName": "",
"backendEnvironmentName": "",
"resourceConfig": [],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateBackendAPI
{{baseUrl}}/backend/:appId/api
QUERY PARAMS
appId
BODY json
{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api");
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api" {:content-type :json
:form-params {:backendEnvironmentName ""
:resourceConfig {:AdditionalAuthTypes ""
:ApiName ""
:ConflictResolution ""
:DefaultAuthType ""
:Service ""
:TransformSchema ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api"),
Content = new StringContent("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api"
payload := strings.NewReader("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 235
{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api")
.setHeader("content-type", "application/json")
.setBody("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api")
.header("content-type", "application/json")
.body("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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}}/backend/:appId/api',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api")
.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/backend/:appId/api',
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({
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api',
headers: {'content-type': 'application/json'},
body: {
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
},
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}}/backend/:appId/api');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
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}}/backend/:appId/api',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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 = @{ @"backendEnvironmentName": @"",
@"resourceConfig": @{ @"AdditionalAuthTypes": @"", @"ApiName": @"", @"ConflictResolution": @"", @"DefaultAuthType": @"", @"Service": @"", @"TransformSchema": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api"]
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}}/backend/:appId/api" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api",
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([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/api', [
'body' => '{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api');
$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}}/backend/:appId/api' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api"
payload = {
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api"
payload <- "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api")
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api') do |req|
req.body = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api";
let payload = json!({
"backendEnvironmentName": "",
"resourceConfig": json!({
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
}),
"resourceName": ""
});
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}}/backend/:appId/api \
--header 'content-type: application/json' \
--data '{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'echo '{
"backendEnvironmentName": "",
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/apiimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"backendEnvironmentName": "",
"resourceConfig": [
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateBackendAuth
{{baseUrl}}/backend/:appId/auth
QUERY PARAMS
appId
BODY json
{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/auth");
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/auth" {:content-type :json
:form-params {:backendEnvironmentName ""
:resourceConfig {:AuthResources ""
:IdentityPoolConfigs ""
:Service ""
:UserPoolConfigs ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/auth"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth"),
Content = new StringContent("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/auth"
payload := strings.NewReader("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/auth HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 184
{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/auth")
.setHeader("content-type", "application/json")
.setBody("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/auth"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/auth")
.header("content-type", "application/json")
.body("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
backendEnvironmentName: '',
resourceConfig: {
AuthResources: '',
IdentityPoolConfigs: '',
Service: '',
UserPoolConfigs: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/auth');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/auth';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"AuthResources":"","IdentityPoolConfigs":"","Service":"","UserPoolConfigs":""},"resourceName":""}'
};
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}}/backend/:appId/auth',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "AuthResources": "",\n "IdentityPoolConfigs": "",\n "Service": "",\n "UserPoolConfigs": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth")
.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/backend/:appId/auth',
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({
backendEnvironmentName: '',
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth',
headers: {'content-type': 'application/json'},
body: {
backendEnvironmentName: '',
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
},
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}}/backend/:appId/auth');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
backendEnvironmentName: '',
resourceConfig: {
AuthResources: '',
IdentityPoolConfigs: '',
Service: '',
UserPoolConfigs: ''
},
resourceName: ''
});
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}}/backend/:appId/auth',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/auth';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"AuthResources":"","IdentityPoolConfigs":"","Service":"","UserPoolConfigs":""},"resourceName":""}'
};
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 = @{ @"backendEnvironmentName": @"",
@"resourceConfig": @{ @"AuthResources": @"", @"IdentityPoolConfigs": @"", @"Service": @"", @"UserPoolConfigs": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/auth"]
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}}/backend/:appId/auth" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/auth",
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([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/auth', [
'body' => '{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/auth');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/auth');
$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}}/backend/:appId/auth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/auth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/auth", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/auth"
payload = {
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/auth"
payload <- "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth")
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/auth') do |req|
req.body = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/auth";
let payload = json!({
"backendEnvironmentName": "",
"resourceConfig": json!({
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
}),
"resourceName": ""
});
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}}/backend/:appId/auth \
--header 'content-type: application/json' \
--data '{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'echo '{
"backendEnvironmentName": "",
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/auth \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "AuthResources": "",\n "IdentityPoolConfigs": "",\n "Service": "",\n "UserPoolConfigs": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/authimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"backendEnvironmentName": "",
"resourceConfig": [
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/auth")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateBackendConfig
{{baseUrl}}/backend/:appId/config
QUERY PARAMS
appId
BODY json
{
"backendManagerAppId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/config");
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 \"backendManagerAppId\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/config" {:content-type :json
:form-params {:backendManagerAppId ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/config"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"backendManagerAppId\": \"\"\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}}/backend/:appId/config"),
Content = new StringContent("{\n \"backendManagerAppId\": \"\"\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}}/backend/:appId/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"backendManagerAppId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/config"
payload := strings.NewReader("{\n \"backendManagerAppId\": \"\"\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/backend/:appId/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31
{
"backendManagerAppId": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/config")
.setHeader("content-type", "application/json")
.setBody("{\n \"backendManagerAppId\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/config"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"backendManagerAppId\": \"\"\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 \"backendManagerAppId\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/config")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/config")
.header("content-type", "application/json")
.body("{\n \"backendManagerAppId\": \"\"\n}")
.asString(); const data = JSON.stringify({
backendManagerAppId: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/config');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/config',
headers: {'content-type': 'application/json'},
data: {backendManagerAppId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/config';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendManagerAppId":""}'
};
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}}/backend/:appId/config',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "backendManagerAppId": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"backendManagerAppId\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/config")
.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/backend/:appId/config',
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({backendManagerAppId: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/config',
headers: {'content-type': 'application/json'},
body: {backendManagerAppId: ''},
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}}/backend/:appId/config');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
backendManagerAppId: ''
});
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}}/backend/:appId/config',
headers: {'content-type': 'application/json'},
data: {backendManagerAppId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/config';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendManagerAppId":""}'
};
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 = @{ @"backendManagerAppId": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/config"]
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}}/backend/:appId/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"backendManagerAppId\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/config",
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([
'backendManagerAppId' => ''
]),
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}}/backend/:appId/config', [
'body' => '{
"backendManagerAppId": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/config');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'backendManagerAppId' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'backendManagerAppId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/config');
$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}}/backend/:appId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendManagerAppId": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendManagerAppId": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"backendManagerAppId\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/config", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/config"
payload = { "backendManagerAppId": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/config"
payload <- "{\n \"backendManagerAppId\": \"\"\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}}/backend/:appId/config")
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 \"backendManagerAppId\": \"\"\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/backend/:appId/config') do |req|
req.body = "{\n \"backendManagerAppId\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/config";
let payload = json!({"backendManagerAppId": ""});
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}}/backend/:appId/config \
--header 'content-type: application/json' \
--data '{
"backendManagerAppId": ""
}'echo '{
"backendManagerAppId": ""
}' | \
http POST {{baseUrl}}/backend/:appId/config \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "backendManagerAppId": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/configimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["backendManagerAppId": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/config")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateBackendStorage
{{baseUrl}}/backend/:appId/storage
QUERY PARAMS
appId
BODY json
{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/storage");
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/storage" {:content-type :json
:form-params {:backendEnvironmentName ""
:resourceConfig {:BucketName ""
:Permissions ""
:ServiceName ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/storage"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage"),
Content = new StringContent("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/storage"
payload := strings.NewReader("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/storage HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 150
{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/storage")
.setHeader("content-type", "application/json")
.setBody("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/storage"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/storage")
.header("content-type", "application/json")
.body("{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
backendEnvironmentName: '',
resourceConfig: {
BucketName: '',
Permissions: '',
ServiceName: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/storage');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {BucketName: '', Permissions: '', ServiceName: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/storage';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"BucketName":"","Permissions":"","ServiceName":""},"resourceName":""}'
};
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}}/backend/:appId/storage',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "BucketName": "",\n "Permissions": "",\n "ServiceName": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage")
.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/backend/:appId/storage',
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({
backendEnvironmentName: '',
resourceConfig: {BucketName: '', Permissions: '', ServiceName: ''},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage',
headers: {'content-type': 'application/json'},
body: {
backendEnvironmentName: '',
resourceConfig: {BucketName: '', Permissions: '', ServiceName: ''},
resourceName: ''
},
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}}/backend/:appId/storage');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
backendEnvironmentName: '',
resourceConfig: {
BucketName: '',
Permissions: '',
ServiceName: ''
},
resourceName: ''
});
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}}/backend/:appId/storage',
headers: {'content-type': 'application/json'},
data: {
backendEnvironmentName: '',
resourceConfig: {BucketName: '', Permissions: '', ServiceName: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/storage';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":"","resourceConfig":{"BucketName":"","Permissions":"","ServiceName":""},"resourceName":""}'
};
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 = @{ @"backendEnvironmentName": @"",
@"resourceConfig": @{ @"BucketName": @"", @"Permissions": @"", @"ServiceName": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/storage"]
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}}/backend/:appId/storage" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/storage",
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([
'backendEnvironmentName' => '',
'resourceConfig' => [
'BucketName' => '',
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/storage', [
'body' => '{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/storage');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'BucketName' => '',
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'backendEnvironmentName' => '',
'resourceConfig' => [
'BucketName' => '',
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/storage');
$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}}/backend/:appId/storage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/storage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/storage", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/storage"
payload = {
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/storage"
payload <- "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage")
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 \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/storage') do |req|
req.body = "{\n \"backendEnvironmentName\": \"\",\n \"resourceConfig\": {\n \"BucketName\": \"\",\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/storage";
let payload = json!({
"backendEnvironmentName": "",
"resourceConfig": json!({
"BucketName": "",
"Permissions": "",
"ServiceName": ""
}),
"resourceName": ""
});
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}}/backend/:appId/storage \
--header 'content-type: application/json' \
--data '{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'echo '{
"backendEnvironmentName": "",
"resourceConfig": {
"BucketName": "",
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/storage \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "backendEnvironmentName": "",\n "resourceConfig": {\n "BucketName": "",\n "Permissions": "",\n "ServiceName": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/storageimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"backendEnvironmentName": "",
"resourceConfig": [
"BucketName": "",
"Permissions": "",
"ServiceName": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/storage")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
CreateToken
{{baseUrl}}/backend/:appId/challenge
QUERY PARAMS
appId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/challenge");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/challenge")require "http/client"
url = "{{baseUrl}}/backend/:appId/challenge"
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}}/backend/:appId/challenge"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/challenge");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/challenge"
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/backend/:appId/challenge HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/challenge")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/challenge"))
.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}}/backend/:appId/challenge")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/challenge")
.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}}/backend/:appId/challenge');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/backend/:appId/challenge'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/challenge';
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}}/backend/:appId/challenge',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/challenge")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/challenge',
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}}/backend/:appId/challenge'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/backend/:appId/challenge');
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}}/backend/:appId/challenge'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/challenge';
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}}/backend/:appId/challenge"]
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}}/backend/:appId/challenge" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/challenge",
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}}/backend/:appId/challenge');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/challenge');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/challenge');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/challenge' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/challenge' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/backend/:appId/challenge")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/challenge"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/challenge"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/challenge")
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/backend/:appId/challenge') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/challenge";
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}}/backend/:appId/challengehttp POST {{baseUrl}}/backend/:appId/challengewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/backend/:appId/challengeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/challenge")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
DeleteBackend
{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove
QUERY PARAMS
appId
backendEnvironmentName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")require "http/client"
url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove"
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}}/backend/:appId/environments/:backendEnvironmentName/remove"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove"
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/backend/:appId/environments/:backendEnvironmentName/remove HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove"))
.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}}/backend/:appId/environments/:backendEnvironmentName/remove")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")
.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}}/backend/:appId/environments/:backendEnvironmentName/remove');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove';
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}}/backend/:appId/environments/:backendEnvironmentName/remove',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/environments/:backendEnvironmentName/remove',
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}}/backend/:appId/environments/:backendEnvironmentName/remove'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove');
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}}/backend/:appId/environments/:backendEnvironmentName/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove';
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}}/backend/:appId/environments/:backendEnvironmentName/remove"]
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}}/backend/:appId/environments/:backendEnvironmentName/remove" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove",
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}}/backend/:appId/environments/:backendEnvironmentName/remove');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/backend/:appId/environments/:backendEnvironmentName/remove")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")
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/backend/:appId/environments/:backendEnvironmentName/remove') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove";
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}}/backend/:appId/environments/:backendEnvironmentName/removehttp POST {{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/removewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/removeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/environments/:backendEnvironmentName/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
DeleteBackendAPI
{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove");
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove" {:content-type :json
:form-params {:resourceConfig {:AdditionalAuthTypes ""
:ApiName ""
:ConflictResolution ""
:DefaultAuthType ""
:Service ""
:TransformSchema ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/remove"),
Content = new StringContent("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/remove");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"
payload := strings.NewReader("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/remove HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 203
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove")
.header("content-type", "application/json")
.body("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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}}/backend/:appId/api/:backendEnvironmentName/remove',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove")
.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/backend/:appId/api/:backendEnvironmentName/remove',
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({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
body: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
},
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}}/backend/:appId/api/:backendEnvironmentName/remove');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
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}}/backend/:appId/api/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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 = @{ @"resourceConfig": @{ @"AdditionalAuthTypes": @"", @"ApiName": @"", @"ConflictResolution": @"", @"DefaultAuthType": @"", @"Service": @"", @"TransformSchema": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"]
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}}/backend/:appId/api/:backendEnvironmentName/remove" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove",
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([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/api/:backendEnvironmentName/remove', [
'body' => '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove');
$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}}/backend/:appId/api/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api/:backendEnvironmentName/remove", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"
payload = {
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove"
payload <- "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/remove")
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/remove') do |req|
req.body = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove";
let payload = json!({
"resourceConfig": json!({
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
}),
"resourceName": ""
});
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}}/backend/:appId/api/:backendEnvironmentName/remove \
--header 'content-type: application/json' \
--data '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'echo '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/removeimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceConfig": [
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
DeleteBackendAuth
{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove");
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 \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove" {:content-type :json
:form-params {:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/remove"),
Content = new StringContent("{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/remove");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"
payload := strings.NewReader("{\n \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/remove HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\"\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 \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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}}/backend/:appId/auth/:backendEnvironmentName/remove',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove")
.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/backend/:appId/auth/:backendEnvironmentName/remove',
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({resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
body: {resourceName: ''},
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}}/backend/:appId/auth/:backendEnvironmentName/remove');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: ''
});
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}}/backend/:appId/auth/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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 = @{ @"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"]
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}}/backend/:appId/auth/:backendEnvironmentName/remove" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove",
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([
'resourceName' => ''
]),
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}}/backend/:appId/auth/:backendEnvironmentName/remove', [
'body' => '{
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove');
$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}}/backend/:appId/auth/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/auth/:backendEnvironmentName/remove", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"
payload = { "resourceName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove"
payload <- "{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/remove")
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 \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/remove') do |req|
req.body = "{\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove";
let payload = json!({"resourceName": ""});
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}}/backend/:appId/auth/:backendEnvironmentName/remove \
--header 'content-type: application/json' \
--data '{
"resourceName": ""
}'echo '{
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/removeimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["resourceName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
DeleteBackendStorage
{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": "",
"serviceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove");
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 \"resourceName\": \"\",\n \"serviceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove" {:content-type :json
:form-params {:resourceName ""
:serviceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/remove"),
Content = new StringContent("{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/remove");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"
payload := strings.NewReader("{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/remove HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45
{
"resourceName": "",
"serviceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\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 \"resourceName\": \"\",\n \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: '',
serviceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {resourceName: '', serviceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":"","serviceName":""}'
};
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}}/backend/:appId/storage/:backendEnvironmentName/remove',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": "",\n "serviceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove")
.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/backend/:appId/storage/:backendEnvironmentName/remove',
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({resourceName: '', serviceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
body: {resourceName: '', serviceName: ''},
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}}/backend/:appId/storage/:backendEnvironmentName/remove');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: '',
serviceName: ''
});
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}}/backend/:appId/storage/:backendEnvironmentName/remove',
headers: {'content-type': 'application/json'},
data: {resourceName: '', serviceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":"","serviceName":""}'
};
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 = @{ @"resourceName": @"",
@"serviceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"]
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}}/backend/:appId/storage/:backendEnvironmentName/remove" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove",
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([
'resourceName' => '',
'serviceName' => ''
]),
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}}/backend/:appId/storage/:backendEnvironmentName/remove', [
'body' => '{
"resourceName": "",
"serviceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => '',
'serviceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => '',
'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove');
$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}}/backend/:appId/storage/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": "",
"serviceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": "",
"serviceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/storage/:backendEnvironmentName/remove", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"
payload = {
"resourceName": "",
"serviceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove"
payload <- "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/remove")
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 \"resourceName\": \"\",\n \"serviceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/remove') do |req|
req.body = "{\n \"resourceName\": \"\",\n \"serviceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove";
let payload = json!({
"resourceName": "",
"serviceName": ""
});
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}}/backend/:appId/storage/:backendEnvironmentName/remove \
--header 'content-type: application/json' \
--data '{
"resourceName": "",
"serviceName": ""
}'echo '{
"resourceName": "",
"serviceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": "",\n "serviceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/removeimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceName": "",
"serviceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
DeleteToken
{{baseUrl}}/backend/:appId/challenge/:sessionId/remove
QUERY PARAMS
appId
sessionId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")require "http/client"
url = "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove"
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}}/backend/:appId/challenge/:sessionId/remove"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/challenge/:sessionId/remove");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove"
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/backend/:appId/challenge/:sessionId/remove HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/challenge/:sessionId/remove"))
.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}}/backend/:appId/challenge/:sessionId/remove")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")
.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}}/backend/:appId/challenge/:sessionId/remove');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove';
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}}/backend/:appId/challenge/:sessionId/remove',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/challenge/:sessionId/remove',
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}}/backend/:appId/challenge/:sessionId/remove'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove');
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}}/backend/:appId/challenge/:sessionId/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove';
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}}/backend/:appId/challenge/:sessionId/remove"]
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}}/backend/:appId/challenge/:sessionId/remove" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove",
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}}/backend/:appId/challenge/:sessionId/remove');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/challenge/:sessionId/remove');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/challenge/:sessionId/remove');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/challenge/:sessionId/remove' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/backend/:appId/challenge/:sessionId/remove")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")
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/backend/:appId/challenge/:sessionId/remove') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove";
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}}/backend/:appId/challenge/:sessionId/removehttp POST {{baseUrl}}/backend/:appId/challenge/:sessionId/removewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/backend/:appId/challenge/:sessionId/removeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/challenge/:sessionId/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GenerateBackendAPIModels
{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels");
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 \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels" {:content-type :json
:form-params {:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/generateModels"),
Content = new StringContent("{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/generateModels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"
payload := strings.NewReader("{\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/generateModels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\"\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 \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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}}/backend/:appId/api/:backendEnvironmentName/generateModels',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels")
.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/backend/:appId/api/:backendEnvironmentName/generateModels',
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({resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels',
headers: {'content-type': 'application/json'},
body: {resourceName: ''},
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}}/backend/:appId/api/:backendEnvironmentName/generateModels');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: ''
});
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}}/backend/:appId/api/:backendEnvironmentName/generateModels',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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 = @{ @"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"]
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}}/backend/:appId/api/:backendEnvironmentName/generateModels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels",
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([
'resourceName' => ''
]),
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}}/backend/:appId/api/:backendEnvironmentName/generateModels', [
'body' => '{
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels');
$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}}/backend/:appId/api/:backendEnvironmentName/generateModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api/:backendEnvironmentName/generateModels", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"
payload = { "resourceName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels"
payload <- "{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/generateModels")
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 \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/generateModels') do |req|
req.body = "{\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels";
let payload = json!({"resourceName": ""});
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}}/backend/:appId/api/:backendEnvironmentName/generateModels \
--header 'content-type: application/json' \
--data '{
"resourceName": ""
}'echo '{
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModelsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["resourceName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/generateModels")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GetBackend
{{baseUrl}}/backend/:appId/details
QUERY PARAMS
appId
BODY json
{
"backendEnvironmentName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/details");
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 \"backendEnvironmentName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/details" {:content-type :json
:form-params {:backendEnvironmentName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/details"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"backendEnvironmentName\": \"\"\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}}/backend/:appId/details"),
Content = new StringContent("{\n \"backendEnvironmentName\": \"\"\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}}/backend/:appId/details");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"backendEnvironmentName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/details"
payload := strings.NewReader("{\n \"backendEnvironmentName\": \"\"\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/backend/:appId/details HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34
{
"backendEnvironmentName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/details")
.setHeader("content-type", "application/json")
.setBody("{\n \"backendEnvironmentName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/details"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"backendEnvironmentName\": \"\"\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 \"backendEnvironmentName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/details")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/details")
.header("content-type", "application/json")
.body("{\n \"backendEnvironmentName\": \"\"\n}")
.asString(); const data = JSON.stringify({
backendEnvironmentName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/details');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/details',
headers: {'content-type': 'application/json'},
data: {backendEnvironmentName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":""}'
};
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}}/backend/:appId/details',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "backendEnvironmentName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"backendEnvironmentName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/details")
.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/backend/:appId/details',
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({backendEnvironmentName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/details',
headers: {'content-type': 'application/json'},
body: {backendEnvironmentName: ''},
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}}/backend/:appId/details');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
backendEnvironmentName: ''
});
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}}/backend/:appId/details',
headers: {'content-type': 'application/json'},
data: {backendEnvironmentName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"backendEnvironmentName":""}'
};
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 = @{ @"backendEnvironmentName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/details"]
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}}/backend/:appId/details" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"backendEnvironmentName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/details",
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([
'backendEnvironmentName' => ''
]),
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}}/backend/:appId/details', [
'body' => '{
"backendEnvironmentName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/details');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'backendEnvironmentName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'backendEnvironmentName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/details');
$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}}/backend/:appId/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"backendEnvironmentName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"backendEnvironmentName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/details", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/details"
payload = { "backendEnvironmentName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/details"
payload <- "{\n \"backendEnvironmentName\": \"\"\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}}/backend/:appId/details")
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 \"backendEnvironmentName\": \"\"\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/backend/:appId/details') do |req|
req.body = "{\n \"backendEnvironmentName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/details";
let payload = json!({"backendEnvironmentName": ""});
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}}/backend/:appId/details \
--header 'content-type: application/json' \
--data '{
"backendEnvironmentName": ""
}'echo '{
"backendEnvironmentName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/details \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "backendEnvironmentName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/detailsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["backendEnvironmentName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GetBackendAPI
{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details");
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details" {:content-type :json
:form-params {:resourceConfig {:AdditionalAuthTypes ""
:ApiName ""
:ConflictResolution ""
:DefaultAuthType ""
:Service ""
:TransformSchema ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/details"),
Content = new StringContent("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/details");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"
payload := strings.NewReader("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/details HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 203
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details")
.header("content-type", "application/json")
.body("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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}}/backend/:appId/api/:backendEnvironmentName/details',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details")
.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/backend/:appId/api/:backendEnvironmentName/details',
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({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
body: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
},
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}}/backend/:appId/api/:backendEnvironmentName/details');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
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}}/backend/:appId/api/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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 = @{ @"resourceConfig": @{ @"AdditionalAuthTypes": @"", @"ApiName": @"", @"ConflictResolution": @"", @"DefaultAuthType": @"", @"Service": @"", @"TransformSchema": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"]
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}}/backend/:appId/api/:backendEnvironmentName/details" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details",
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([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/api/:backendEnvironmentName/details', [
'body' => '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details');
$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}}/backend/:appId/api/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api/:backendEnvironmentName/details", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"
payload = {
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details"
payload <- "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/details")
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/details') do |req|
req.body = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details";
let payload = json!({
"resourceConfig": json!({
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
}),
"resourceName": ""
});
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}}/backend/:appId/api/:backendEnvironmentName/details \
--header 'content-type: application/json' \
--data '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'echo '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/detailsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceConfig": [
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GetBackendAPIModels
{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels");
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 \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels" {:content-type :json
:form-params {:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/getModels"),
Content = new StringContent("{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/getModels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"
payload := strings.NewReader("{\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/getModels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\"\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 \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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}}/backend/:appId/api/:backendEnvironmentName/getModels',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels")
.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/backend/:appId/api/:backendEnvironmentName/getModels',
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({resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels',
headers: {'content-type': 'application/json'},
body: {resourceName: ''},
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}}/backend/:appId/api/:backendEnvironmentName/getModels');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: ''
});
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}}/backend/:appId/api/:backendEnvironmentName/getModels',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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 = @{ @"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"]
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}}/backend/:appId/api/:backendEnvironmentName/getModels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels",
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([
'resourceName' => ''
]),
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}}/backend/:appId/api/:backendEnvironmentName/getModels', [
'body' => '{
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels');
$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}}/backend/:appId/api/:backendEnvironmentName/getModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api/:backendEnvironmentName/getModels", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"
payload = { "resourceName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels"
payload <- "{\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName/getModels")
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 \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName/getModels') do |req|
req.body = "{\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels";
let payload = json!({"resourceName": ""});
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}}/backend/:appId/api/:backendEnvironmentName/getModels \
--header 'content-type: application/json' \
--data '{
"resourceName": ""
}'echo '{
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModelsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["resourceName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName/getModels")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GetBackendAuth
{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details");
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 \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details" {:content-type :json
:form-params {:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/details"),
Content = new StringContent("{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/details");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"
payload := strings.NewReader("{\n \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/details HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\"\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 \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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}}/backend/:appId/auth/:backendEnvironmentName/details',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details")
.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/backend/:appId/auth/:backendEnvironmentName/details',
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({resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
body: {resourceName: ''},
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}}/backend/:appId/auth/:backendEnvironmentName/details');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: ''
});
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}}/backend/:appId/auth/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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 = @{ @"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"]
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}}/backend/:appId/auth/:backendEnvironmentName/details" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details",
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([
'resourceName' => ''
]),
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}}/backend/:appId/auth/:backendEnvironmentName/details', [
'body' => '{
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details');
$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}}/backend/:appId/auth/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/auth/:backendEnvironmentName/details", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"
payload = { "resourceName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details"
payload <- "{\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/details")
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 \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/details') do |req|
req.body = "{\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details";
let payload = json!({"resourceName": ""});
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}}/backend/:appId/auth/:backendEnvironmentName/details \
--header 'content-type: application/json' \
--data '{
"resourceName": ""
}'echo '{
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/detailsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["resourceName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
GetBackendJob
{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId
QUERY PARAMS
appId
backendEnvironmentName
jobId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")require "http/client"
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/backend/:appId/job/:backendEnvironmentName/:jobId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/job/:backendEnvironmentName/:jobId',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/backend/:appId/job/:backendEnvironmentName/:jobId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/backend/:appId/job/:backendEnvironmentName/:jobId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobIdhttp GET {{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
GetBackendStorage
{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details");
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 \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details" {:content-type :json
:form-params {:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/details"),
Content = new StringContent("{\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/details");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"
payload := strings.NewReader("{\n \"resourceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/details HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceName\": \"\"\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 \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details")
.header("content-type", "application/json")
.body("{\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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}}/backend/:appId/storage/:backendEnvironmentName/details',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details")
.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/backend/:appId/storage/:backendEnvironmentName/details',
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({resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
body: {resourceName: ''},
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}}/backend/:appId/storage/:backendEnvironmentName/details');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceName: ''
});
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}}/backend/:appId/storage/:backendEnvironmentName/details',
headers: {'content-type': 'application/json'},
data: {resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceName":""}'
};
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 = @{ @"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"]
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}}/backend/:appId/storage/:backendEnvironmentName/details" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details",
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([
'resourceName' => ''
]),
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}}/backend/:appId/storage/:backendEnvironmentName/details', [
'body' => '{
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details');
$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}}/backend/:appId/storage/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/storage/:backendEnvironmentName/details", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"
payload = { "resourceName": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details"
payload <- "{\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/details")
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 \"resourceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/details') do |req|
req.body = "{\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details";
let payload = json!({"resourceName": ""});
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}}/backend/:appId/storage/:backendEnvironmentName/details \
--header 'content-type: application/json' \
--data '{
"resourceName": ""
}'echo '{
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/detailsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["resourceName": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
GetToken
{{baseUrl}}/backend/:appId/challenge/:sessionId
QUERY PARAMS
appId
sessionId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/challenge/:sessionId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/backend/:appId/challenge/:sessionId")require "http/client"
url = "{{baseUrl}}/backend/:appId/challenge/:sessionId"
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}}/backend/:appId/challenge/:sessionId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/challenge/:sessionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/challenge/:sessionId"
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/backend/:appId/challenge/:sessionId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backend/:appId/challenge/:sessionId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/challenge/:sessionId"))
.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}}/backend/:appId/challenge/:sessionId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/backend/:appId/challenge/:sessionId")
.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}}/backend/:appId/challenge/:sessionId');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/backend/:appId/challenge/:sessionId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/challenge/:sessionId';
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}}/backend/:appId/challenge/:sessionId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/challenge/:sessionId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/challenge/:sessionId',
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}}/backend/:appId/challenge/:sessionId'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/backend/:appId/challenge/:sessionId');
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}}/backend/:appId/challenge/:sessionId'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/challenge/:sessionId';
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}}/backend/:appId/challenge/:sessionId"]
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}}/backend/:appId/challenge/:sessionId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/challenge/:sessionId",
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}}/backend/:appId/challenge/:sessionId');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/challenge/:sessionId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/challenge/:sessionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/challenge/:sessionId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/challenge/:sessionId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/backend/:appId/challenge/:sessionId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/challenge/:sessionId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/challenge/:sessionId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/challenge/:sessionId")
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/backend/:appId/challenge/:sessionId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/challenge/:sessionId";
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}}/backend/:appId/challenge/:sessionIdhttp GET {{baseUrl}}/backend/:appId/challenge/:sessionIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/backend/:appId/challenge/:sessionIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/challenge/:sessionId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
ImportBackendAuth
{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import");
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 \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import" {:content-type :json
:form-params {:identityPoolId ""
:nativeClientId ""
:userPoolId ""
:webClientId ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/import"),
Content = new StringContent("{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"
payload := strings.NewReader("{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/import HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91
{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import")
.setHeader("content-type", "application/json")
.setBody("{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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 \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import")
.header("content-type", "application/json")
.body("{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}")
.asString(); const data = JSON.stringify({
identityPoolId: '',
nativeClientId: '',
userPoolId: '',
webClientId: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
data: {identityPoolId: '', nativeClientId: '', userPoolId: '', webClientId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"identityPoolId":"","nativeClientId":"","userPoolId":"","webClientId":""}'
};
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}}/backend/:appId/auth/:backendEnvironmentName/import',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "identityPoolId": "",\n "nativeClientId": "",\n "userPoolId": "",\n "webClientId": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import")
.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/backend/:appId/auth/:backendEnvironmentName/import',
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({identityPoolId: '', nativeClientId: '', userPoolId: '', webClientId: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
body: {identityPoolId: '', nativeClientId: '', userPoolId: '', webClientId: ''},
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}}/backend/:appId/auth/:backendEnvironmentName/import');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
identityPoolId: '',
nativeClientId: '',
userPoolId: '',
webClientId: ''
});
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}}/backend/:appId/auth/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
data: {identityPoolId: '', nativeClientId: '', userPoolId: '', webClientId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"identityPoolId":"","nativeClientId":"","userPoolId":"","webClientId":""}'
};
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 = @{ @"identityPoolId": @"",
@"nativeClientId": @"",
@"userPoolId": @"",
@"webClientId": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"]
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}}/backend/:appId/auth/:backendEnvironmentName/import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import",
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([
'identityPoolId' => '',
'nativeClientId' => '',
'userPoolId' => '',
'webClientId' => ''
]),
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}}/backend/:appId/auth/:backendEnvironmentName/import', [
'body' => '{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'identityPoolId' => '',
'nativeClientId' => '',
'userPoolId' => '',
'webClientId' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'identityPoolId' => '',
'nativeClientId' => '',
'userPoolId' => '',
'webClientId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import');
$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}}/backend/:appId/auth/:backendEnvironmentName/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/auth/:backendEnvironmentName/import", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"
payload = {
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import"
payload <- "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName/import")
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 \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\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/backend/:appId/auth/:backendEnvironmentName/import') do |req|
req.body = "{\n \"identityPoolId\": \"\",\n \"nativeClientId\": \"\",\n \"userPoolId\": \"\",\n \"webClientId\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import";
let payload = json!({
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
});
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}}/backend/:appId/auth/:backendEnvironmentName/import \
--header 'content-type: application/json' \
--data '{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}'echo '{
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
}' | \
http POST {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "identityPoolId": "",\n "nativeClientId": "",\n "userPoolId": "",\n "webClientId": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/importimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"identityPoolId": "",
"nativeClientId": "",
"userPoolId": "",
"webClientId": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName/import")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
ImportBackendStorage
{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"bucketName": "",
"serviceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import");
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 \"bucketName\": \"\",\n \"serviceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import" {:content-type :json
:form-params {:bucketName ""
:serviceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/import"),
Content = new StringContent("{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"
payload := strings.NewReader("{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/import HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 43
{
"bucketName": "",
"serviceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import")
.setHeader("content-type", "application/json")
.setBody("{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\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 \"bucketName\": \"\",\n \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import")
.header("content-type", "application/json")
.body("{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
bucketName: '',
serviceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
data: {bucketName: '', serviceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"bucketName":"","serviceName":""}'
};
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}}/backend/:appId/storage/:backendEnvironmentName/import',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "bucketName": "",\n "serviceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import")
.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/backend/:appId/storage/:backendEnvironmentName/import',
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({bucketName: '', serviceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
body: {bucketName: '', serviceName: ''},
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}}/backend/:appId/storage/:backendEnvironmentName/import');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
bucketName: '',
serviceName: ''
});
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}}/backend/:appId/storage/:backendEnvironmentName/import',
headers: {'content-type': 'application/json'},
data: {bucketName: '', serviceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"bucketName":"","serviceName":""}'
};
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 = @{ @"bucketName": @"",
@"serviceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"]
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}}/backend/:appId/storage/:backendEnvironmentName/import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import",
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([
'bucketName' => '',
'serviceName' => ''
]),
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}}/backend/:appId/storage/:backendEnvironmentName/import', [
'body' => '{
"bucketName": "",
"serviceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'bucketName' => '',
'serviceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'bucketName' => '',
'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import');
$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}}/backend/:appId/storage/:backendEnvironmentName/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"bucketName": "",
"serviceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"bucketName": "",
"serviceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/storage/:backendEnvironmentName/import", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"
payload = {
"bucketName": "",
"serviceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import"
payload <- "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName/import")
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 \"bucketName\": \"\",\n \"serviceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName/import') do |req|
req.body = "{\n \"bucketName\": \"\",\n \"serviceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import";
let payload = json!({
"bucketName": "",
"serviceName": ""
});
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}}/backend/:appId/storage/:backendEnvironmentName/import \
--header 'content-type: application/json' \
--data '{
"bucketName": "",
"serviceName": ""
}'echo '{
"bucketName": "",
"serviceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "bucketName": "",\n "serviceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/importimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"bucketName": "",
"serviceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName/import")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
ListBackendJobs
{{baseUrl}}/backend/:appId/job/:backendEnvironmentName
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName");
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 \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName" {:content-type :json
:form-params {:jobId ""
:maxResults 0
:nextToken ""
:operation ""
:status ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName"),
Content = new StringContent("{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"
payload := strings.NewReader("{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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/backend/:appId/job/:backendEnvironmentName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90
{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName")
.setHeader("content-type", "application/json")
.setBody("{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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 \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName")
.header("content-type", "application/json")
.body("{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}")
.asString(); const data = JSON.stringify({
jobId: '',
maxResults: 0,
nextToken: '',
operation: '',
status: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {jobId: '', maxResults: 0, nextToken: '', operation: '', status: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"jobId":"","maxResults":0,"nextToken":"","operation":"","status":""}'
};
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}}/backend/:appId/job/:backendEnvironmentName',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "jobId": "",\n "maxResults": 0,\n "nextToken": "",\n "operation": "",\n "status": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName")
.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/backend/:appId/job/:backendEnvironmentName',
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({jobId: '', maxResults: 0, nextToken: '', operation: '', status: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
body: {jobId: '', maxResults: 0, nextToken: '', operation: '', status: ''},
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}}/backend/:appId/job/:backendEnvironmentName');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
jobId: '',
maxResults: 0,
nextToken: '',
operation: '',
status: ''
});
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}}/backend/:appId/job/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {jobId: '', maxResults: 0, nextToken: '', operation: '', status: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"jobId":"","maxResults":0,"nextToken":"","operation":"","status":""}'
};
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 = @{ @"jobId": @"",
@"maxResults": @0,
@"nextToken": @"",
@"operation": @"",
@"status": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"]
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}}/backend/:appId/job/:backendEnvironmentName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName",
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([
'jobId' => '',
'maxResults' => 0,
'nextToken' => '',
'operation' => '',
'status' => ''
]),
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}}/backend/:appId/job/:backendEnvironmentName', [
'body' => '{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'jobId' => '',
'maxResults' => 0,
'nextToken' => '',
'operation' => '',
'status' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'jobId' => '',
'maxResults' => 0,
'nextToken' => '',
'operation' => '',
'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName');
$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}}/backend/:appId/job/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/job/:backendEnvironmentName", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"
payload = {
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName"
payload <- "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName")
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 \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\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/backend/:appId/job/:backendEnvironmentName') do |req|
req.body = "{\n \"jobId\": \"\",\n \"maxResults\": 0,\n \"nextToken\": \"\",\n \"operation\": \"\",\n \"status\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName";
let payload = json!({
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
});
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}}/backend/:appId/job/:backendEnvironmentName \
--header 'content-type: application/json' \
--data '{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}'echo '{
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
}' | \
http POST {{baseUrl}}/backend/:appId/job/:backendEnvironmentName \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "jobId": "",\n "maxResults": 0,\n "nextToken": "",\n "operation": "",\n "status": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/job/:backendEnvironmentNameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"jobId": "",
"maxResults": 0,
"nextToken": "",
"operation": "",
"status": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
ListS3Buckets
{{baseUrl}}/s3Buckets
BODY json
{
"nextToken": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/s3Buckets");
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 \"nextToken\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/s3Buckets" {:content-type :json
:form-params {:nextToken ""}})require "http/client"
url = "{{baseUrl}}/s3Buckets"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"nextToken\": \"\"\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}}/s3Buckets"),
Content = new StringContent("{\n \"nextToken\": \"\"\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}}/s3Buckets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/s3Buckets"
payload := strings.NewReader("{\n \"nextToken\": \"\"\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/s3Buckets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21
{
"nextToken": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/s3Buckets")
.setHeader("content-type", "application/json")
.setBody("{\n \"nextToken\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/s3Buckets"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"nextToken\": \"\"\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 \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/s3Buckets")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/s3Buckets")
.header("content-type", "application/json")
.body("{\n \"nextToken\": \"\"\n}")
.asString(); const data = JSON.stringify({
nextToken: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/s3Buckets');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/s3Buckets',
headers: {'content-type': 'application/json'},
data: {nextToken: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/s3Buckets';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"nextToken":""}'
};
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}}/s3Buckets',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "nextToken": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"nextToken\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/s3Buckets")
.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/s3Buckets',
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({nextToken: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/s3Buckets',
headers: {'content-type': 'application/json'},
body: {nextToken: ''},
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}}/s3Buckets');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
nextToken: ''
});
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}}/s3Buckets',
headers: {'content-type': 'application/json'},
data: {nextToken: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/s3Buckets';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"nextToken":""}'
};
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 = @{ @"nextToken": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/s3Buckets"]
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}}/s3Buckets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"nextToken\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/s3Buckets",
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([
'nextToken' => ''
]),
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}}/s3Buckets', [
'body' => '{
"nextToken": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/s3Buckets');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'nextToken' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/s3Buckets');
$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}}/s3Buckets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"nextToken": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/s3Buckets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"nextToken": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"nextToken\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/s3Buckets", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/s3Buckets"
payload = { "nextToken": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/s3Buckets"
payload <- "{\n \"nextToken\": \"\"\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}}/s3Buckets")
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 \"nextToken\": \"\"\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/s3Buckets') do |req|
req.body = "{\n \"nextToken\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/s3Buckets";
let payload = json!({"nextToken": ""});
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}}/s3Buckets \
--header 'content-type: application/json' \
--data '{
"nextToken": ""
}'echo '{
"nextToken": ""
}' | \
http POST {{baseUrl}}/s3Buckets \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "nextToken": ""\n}' \
--output-document \
- {{baseUrl}}/s3Bucketsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["nextToken": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/s3Buckets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
RemoveAllBackends
{{baseUrl}}/backend/:appId/remove
QUERY PARAMS
appId
BODY json
{
"cleanAmplifyApp": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/remove");
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 \"cleanAmplifyApp\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/remove" {:content-type :json
:form-params {:cleanAmplifyApp false}})require "http/client"
url = "{{baseUrl}}/backend/:appId/remove"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"cleanAmplifyApp\": false\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}}/backend/:appId/remove"),
Content = new StringContent("{\n \"cleanAmplifyApp\": 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}}/backend/:appId/remove");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"cleanAmplifyApp\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/remove"
payload := strings.NewReader("{\n \"cleanAmplifyApp\": false\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/backend/:appId/remove HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 30
{
"cleanAmplifyApp": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/remove")
.setHeader("content-type", "application/json")
.setBody("{\n \"cleanAmplifyApp\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/remove"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"cleanAmplifyApp\": 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 \"cleanAmplifyApp\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/remove")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/remove")
.header("content-type", "application/json")
.body("{\n \"cleanAmplifyApp\": false\n}")
.asString(); const data = JSON.stringify({
cleanAmplifyApp: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/remove');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/remove',
headers: {'content-type': 'application/json'},
data: {cleanAmplifyApp: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cleanAmplifyApp":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}}/backend/:appId/remove',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "cleanAmplifyApp": 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 \"cleanAmplifyApp\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/remove")
.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/backend/:appId/remove',
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({cleanAmplifyApp: false}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/remove',
headers: {'content-type': 'application/json'},
body: {cleanAmplifyApp: false},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/backend/:appId/remove');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
cleanAmplifyApp: false
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/remove',
headers: {'content-type': 'application/json'},
data: {cleanAmplifyApp: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/remove';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cleanAmplifyApp":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 = @{ @"cleanAmplifyApp": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/remove"]
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}}/backend/:appId/remove" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"cleanAmplifyApp\": false\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/remove",
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([
'cleanAmplifyApp' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/backend/:appId/remove', [
'body' => '{
"cleanAmplifyApp": false
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/remove');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'cleanAmplifyApp' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'cleanAmplifyApp' => null
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/remove');
$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}}/backend/:appId/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cleanAmplifyApp": false
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/remove' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cleanAmplifyApp": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"cleanAmplifyApp\": false\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/remove", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/remove"
payload = { "cleanAmplifyApp": False }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/remove"
payload <- "{\n \"cleanAmplifyApp\": false\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/remove")
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 \"cleanAmplifyApp\": 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.post('/baseUrl/backend/:appId/remove') do |req|
req.body = "{\n \"cleanAmplifyApp\": false\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/remove";
let payload = json!({"cleanAmplifyApp": false});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/backend/:appId/remove \
--header 'content-type: application/json' \
--data '{
"cleanAmplifyApp": false
}'echo '{
"cleanAmplifyApp": false
}' | \
http POST {{baseUrl}}/backend/:appId/remove \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "cleanAmplifyApp": false\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/removeimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["cleanAmplifyApp": false] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
RemoveBackendConfig
{{baseUrl}}/backend/:appId/config/remove
QUERY PARAMS
appId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/config/remove");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/config/remove")require "http/client"
url = "{{baseUrl}}/backend/:appId/config/remove"
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}}/backend/:appId/config/remove"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/config/remove");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/config/remove"
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/backend/:appId/config/remove HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/config/remove")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/config/remove"))
.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}}/backend/:appId/config/remove")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/config/remove")
.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}}/backend/:appId/config/remove');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/config/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/config/remove';
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}}/backend/:appId/config/remove',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/config/remove")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/backend/:appId/config/remove',
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}}/backend/:appId/config/remove'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/backend/:appId/config/remove');
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}}/backend/:appId/config/remove'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/config/remove';
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}}/backend/:appId/config/remove"]
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}}/backend/:appId/config/remove" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/config/remove",
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}}/backend/:appId/config/remove');
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/config/remove');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/backend/:appId/config/remove');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/backend/:appId/config/remove' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/config/remove' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/backend/:appId/config/remove")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/config/remove"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/config/remove"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/config/remove")
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/backend/:appId/config/remove') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/config/remove";
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}}/backend/:appId/config/removehttp POST {{baseUrl}}/backend/:appId/config/removewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/backend/:appId/config/removeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/config/remove")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
UpdateBackendAPI
{{baseUrl}}/backend/:appId/api/:backendEnvironmentName
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName");
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName" {:content-type :json
:form-params {:resourceConfig {:AdditionalAuthTypes ""
:ApiName ""
:ConflictResolution ""
:DefaultAuthType ""
:Service ""
:TransformSchema ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName"),
Content = new StringContent("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"
payload := strings.NewReader("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 203
{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName")
.header("content-type", "application/json")
.body("{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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}}/backend/:appId/api/:backendEnvironmentName',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/api/:backendEnvironmentName")
.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/backend/:appId/api/:backendEnvironmentName',
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({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
body: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
},
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}}/backend/:appId/api/:backendEnvironmentName');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
});
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}}/backend/:appId/api/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {
AdditionalAuthTypes: '',
ApiName: '',
ConflictResolution: '',
DefaultAuthType: '',
Service: '',
TransformSchema: ''
},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AdditionalAuthTypes":"","ApiName":"","ConflictResolution":"","DefaultAuthType":"","Service":"","TransformSchema":""},"resourceName":""}'
};
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 = @{ @"resourceConfig": @{ @"AdditionalAuthTypes": @"", @"ApiName": @"", @"ConflictResolution": @"", @"DefaultAuthType": @"", @"Service": @"", @"TransformSchema": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"]
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}}/backend/:appId/api/:backendEnvironmentName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName",
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([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/api/:backendEnvironmentName', [
'body' => '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceConfig' => [
'AdditionalAuthTypes' => '',
'ApiName' => '',
'ConflictResolution' => '',
'DefaultAuthType' => '',
'Service' => '',
'TransformSchema' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/api/:backendEnvironmentName');
$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}}/backend/:appId/api/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/api/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/api/:backendEnvironmentName", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"
payload = {
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName"
payload <- "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/api/:backendEnvironmentName")
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 \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/api/:backendEnvironmentName') do |req|
req.body = "{\n \"resourceConfig\": {\n \"AdditionalAuthTypes\": \"\",\n \"ApiName\": \"\",\n \"ConflictResolution\": \"\",\n \"DefaultAuthType\": \"\",\n \"Service\": \"\",\n \"TransformSchema\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName";
let payload = json!({
"resourceConfig": json!({
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
}),
"resourceName": ""
});
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}}/backend/:appId/api/:backendEnvironmentName \
--header 'content-type: application/json' \
--data '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}'echo '{
"resourceConfig": {
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/api/:backendEnvironmentName \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceConfig": {\n "AdditionalAuthTypes": "",\n "ApiName": "",\n "ConflictResolution": "",\n "DefaultAuthType": "",\n "Service": "",\n "TransformSchema": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/api/:backendEnvironmentNameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceConfig": [
"AdditionalAuthTypes": "",
"ApiName": "",
"ConflictResolution": "",
"DefaultAuthType": "",
"Service": "",
"TransformSchema": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/api/:backendEnvironmentName")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
UpdateBackendAuth
{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName");
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 \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName" {:content-type :json
:form-params {:resourceConfig {:AuthResources ""
:IdentityPoolConfigs ""
:Service ""
:UserPoolConfigs ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName"),
Content = new StringContent("{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"
payload := strings.NewReader("{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 152
{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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 \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName")
.header("content-type", "application/json")
.body("{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceConfig: {
AuthResources: '',
IdentityPoolConfigs: '',
Service: '',
UserPoolConfigs: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AuthResources":"","IdentityPoolConfigs":"","Service":"","UserPoolConfigs":""},"resourceName":""}'
};
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}}/backend/:appId/auth/:backendEnvironmentName',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceConfig": {\n "AuthResources": "",\n "IdentityPoolConfigs": "",\n "Service": "",\n "UserPoolConfigs": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName")
.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/backend/:appId/auth/:backendEnvironmentName',
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({
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
body: {
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
},
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}}/backend/:appId/auth/:backendEnvironmentName');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceConfig: {
AuthResources: '',
IdentityPoolConfigs: '',
Service: '',
UserPoolConfigs: ''
},
resourceName: ''
});
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}}/backend/:appId/auth/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {
resourceConfig: {AuthResources: '', IdentityPoolConfigs: '', Service: '', UserPoolConfigs: ''},
resourceName: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"AuthResources":"","IdentityPoolConfigs":"","Service":"","UserPoolConfigs":""},"resourceName":""}'
};
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 = @{ @"resourceConfig": @{ @"AuthResources": @"", @"IdentityPoolConfigs": @"", @"Service": @"", @"UserPoolConfigs": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"]
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}}/backend/:appId/auth/:backendEnvironmentName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName",
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([
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/auth/:backendEnvironmentName', [
'body' => '{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceConfig' => [
'AuthResources' => '',
'IdentityPoolConfigs' => '',
'Service' => '',
'UserPoolConfigs' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName');
$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}}/backend/:appId/auth/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/auth/:backendEnvironmentName", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"
payload = {
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName"
payload <- "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/auth/:backendEnvironmentName")
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 \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/auth/:backendEnvironmentName') do |req|
req.body = "{\n \"resourceConfig\": {\n \"AuthResources\": \"\",\n \"IdentityPoolConfigs\": \"\",\n \"Service\": \"\",\n \"UserPoolConfigs\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName";
let payload = json!({
"resourceConfig": json!({
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
}),
"resourceName": ""
});
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}}/backend/:appId/auth/:backendEnvironmentName \
--header 'content-type: application/json' \
--data '{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}'echo '{
"resourceConfig": {
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/auth/:backendEnvironmentName \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceConfig": {\n "AuthResources": "",\n "IdentityPoolConfigs": "",\n "Service": "",\n "UserPoolConfigs": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/auth/:backendEnvironmentNameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceConfig": [
"AuthResources": "",
"IdentityPoolConfigs": "",
"Service": "",
"UserPoolConfigs": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/auth/:backendEnvironmentName")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
UpdateBackendConfig
{{baseUrl}}/backend/:appId/config/update
QUERY PARAMS
appId
BODY json
{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/config/update");
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 \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/config/update" {:content-type :json
:form-params {:loginAuthConfig {:AwsCognitoIdentityPoolId ""
:AwsCognitoRegion ""
:AwsUserPoolsId ""
:AwsUserPoolsWebClientId ""}}})require "http/client"
url = "{{baseUrl}}/backend/:appId/config/update"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\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}}/backend/:appId/config/update"),
Content = new StringContent("{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/backend/:appId/config/update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/config/update"
payload := strings.NewReader("{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/backend/:appId/config/update HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 154
{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/config/update")
.setHeader("content-type", "application/json")
.setBody("{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/config/update"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/config/update")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/config/update")
.header("content-type", "application/json")
.body("{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}")
.asString(); const data = JSON.stringify({
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/config/update');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/config/update',
headers: {'content-type': 'application/json'},
data: {
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/config/update';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"loginAuthConfig":{"AwsCognitoIdentityPoolId":"","AwsCognitoRegion":"","AwsUserPoolsId":"","AwsUserPoolsWebClientId":""}}'
};
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}}/backend/:appId/config/update',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "loginAuthConfig": {\n "AwsCognitoIdentityPoolId": "",\n "AwsCognitoRegion": "",\n "AwsUserPoolsId": "",\n "AwsUserPoolsWebClientId": ""\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/config/update")
.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/backend/:appId/config/update',
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({
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/config/update',
headers: {'content-type': 'application/json'},
body: {
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
},
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}}/backend/:appId/config/update');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
});
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}}/backend/:appId/config/update',
headers: {'content-type': 'application/json'},
data: {
loginAuthConfig: {
AwsCognitoIdentityPoolId: '',
AwsCognitoRegion: '',
AwsUserPoolsId: '',
AwsUserPoolsWebClientId: ''
}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/config/update';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"loginAuthConfig":{"AwsCognitoIdentityPoolId":"","AwsCognitoRegion":"","AwsUserPoolsId":"","AwsUserPoolsWebClientId":""}}'
};
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 = @{ @"loginAuthConfig": @{ @"AwsCognitoIdentityPoolId": @"", @"AwsCognitoRegion": @"", @"AwsUserPoolsId": @"", @"AwsUserPoolsWebClientId": @"" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/config/update"]
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}}/backend/:appId/config/update" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/config/update",
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([
'loginAuthConfig' => [
'AwsCognitoIdentityPoolId' => '',
'AwsCognitoRegion' => '',
'AwsUserPoolsId' => '',
'AwsUserPoolsWebClientId' => ''
]
]),
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}}/backend/:appId/config/update', [
'body' => '{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/config/update');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'loginAuthConfig' => [
'AwsCognitoIdentityPoolId' => '',
'AwsCognitoRegion' => '',
'AwsUserPoolsId' => '',
'AwsUserPoolsWebClientId' => ''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'loginAuthConfig' => [
'AwsCognitoIdentityPoolId' => '',
'AwsCognitoRegion' => '',
'AwsUserPoolsId' => '',
'AwsUserPoolsWebClientId' => ''
]
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/config/update');
$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}}/backend/:appId/config/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/config/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/config/update", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/config/update"
payload = { "loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
} }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/config/update"
payload <- "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/backend/:appId/config/update")
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 \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\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/backend/:appId/config/update') do |req|
req.body = "{\n \"loginAuthConfig\": {\n \"AwsCognitoIdentityPoolId\": \"\",\n \"AwsCognitoRegion\": \"\",\n \"AwsUserPoolsId\": \"\",\n \"AwsUserPoolsWebClientId\": \"\"\n }\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/config/update";
let payload = json!({"loginAuthConfig": json!({
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
})});
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}}/backend/:appId/config/update \
--header 'content-type: application/json' \
--data '{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}'echo '{
"loginAuthConfig": {
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
}
}' | \
http POST {{baseUrl}}/backend/:appId/config/update \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "loginAuthConfig": {\n "AwsCognitoIdentityPoolId": "",\n "AwsCognitoRegion": "",\n "AwsUserPoolsId": "",\n "AwsUserPoolsWebClientId": ""\n }\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/config/updateimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["loginAuthConfig": [
"AwsCognitoIdentityPoolId": "",
"AwsCognitoRegion": "",
"AwsUserPoolsId": "",
"AwsUserPoolsWebClientId": ""
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/config/update")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
UpdateBackendJob
{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId
QUERY PARAMS
appId
backendEnvironmentName
jobId
BODY json
{
"operation": "",
"status": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId");
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 \"operation\": \"\",\n \"status\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId" {:content-type :json
:form-params {:operation ""
:status ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName/:jobId"),
Content = new StringContent("{\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName/:jobId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"operation\": \"\",\n \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
payload := strings.NewReader("{\n \"operation\": \"\",\n \"status\": \"\"\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/backend/:appId/job/:backendEnvironmentName/:jobId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 37
{
"operation": "",
"status": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.setHeader("content-type", "application/json")
.setBody("{\n \"operation\": \"\",\n \"status\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"operation\": \"\",\n \"status\": \"\"\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 \"operation\": \"\",\n \"status\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.header("content-type", "application/json")
.body("{\n \"operation\": \"\",\n \"status\": \"\"\n}")
.asString(); const data = JSON.stringify({
operation: '',
status: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId',
headers: {'content-type': 'application/json'},
data: {operation: '', status: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"operation":"","status":""}'
};
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}}/backend/:appId/job/:backendEnvironmentName/:jobId',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "operation": "",\n "status": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"operation\": \"\",\n \"status\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")
.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/backend/:appId/job/:backendEnvironmentName/:jobId',
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({operation: '', status: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId',
headers: {'content-type': 'application/json'},
body: {operation: '', status: ''},
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}}/backend/:appId/job/:backendEnvironmentName/:jobId');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
operation: '',
status: ''
});
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}}/backend/:appId/job/:backendEnvironmentName/:jobId',
headers: {'content-type': 'application/json'},
data: {operation: '', status: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"operation":"","status":""}'
};
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 = @{ @"operation": @"",
@"status": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"]
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}}/backend/:appId/job/:backendEnvironmentName/:jobId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"operation\": \"\",\n \"status\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId",
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([
'operation' => '',
'status' => ''
]),
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}}/backend/:appId/job/:backendEnvironmentName/:jobId', [
'body' => '{
"operation": "",
"status": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'operation' => '',
'status' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'operation' => '',
'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId');
$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}}/backend/:appId/job/:backendEnvironmentName/:jobId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"operation": "",
"status": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"operation": "",
"status": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"operation\": \"\",\n \"status\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/job/:backendEnvironmentName/:jobId", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
payload = {
"operation": "",
"status": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId"
payload <- "{\n \"operation\": \"\",\n \"status\": \"\"\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}}/backend/:appId/job/:backendEnvironmentName/:jobId")
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 \"operation\": \"\",\n \"status\": \"\"\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/backend/:appId/job/:backendEnvironmentName/:jobId') do |req|
req.body = "{\n \"operation\": \"\",\n \"status\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId";
let payload = json!({
"operation": "",
"status": ""
});
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}}/backend/:appId/job/:backendEnvironmentName/:jobId \
--header 'content-type: application/json' \
--data '{
"operation": "",
"status": ""
}'echo '{
"operation": "",
"status": ""
}' | \
http POST {{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "operation": "",\n "status": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobIdimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"operation": "",
"status": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/job/:backendEnvironmentName/:jobId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
UpdateBackendStorage
{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName
QUERY PARAMS
appId
backendEnvironmentName
BODY json
{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName");
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 \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName" {:content-type :json
:form-params {:resourceConfig {:Permissions ""
:ServiceName ""}
:resourceName ""}})require "http/client"
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName"),
Content = new StringContent("{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"
payload := strings.NewReader("{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96
{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName")
.setHeader("content-type", "application/json")
.setBody("{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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 \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName")
.header("content-type", "application/json")
.body("{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
.asString(); const data = JSON.stringify({
resourceConfig: {
Permissions: '',
ServiceName: ''
},
resourceName: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {resourceConfig: {Permissions: '', ServiceName: ''}, resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"Permissions":"","ServiceName":""},"resourceName":""}'
};
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}}/backend/:appId/storage/:backendEnvironmentName',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "resourceConfig": {\n "Permissions": "",\n "ServiceName": ""\n },\n "resourceName": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName")
.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/backend/:appId/storage/:backendEnvironmentName',
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({resourceConfig: {Permissions: '', ServiceName: ''}, resourceName: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
body: {resourceConfig: {Permissions: '', ServiceName: ''}, resourceName: ''},
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}}/backend/:appId/storage/:backendEnvironmentName');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
resourceConfig: {
Permissions: '',
ServiceName: ''
},
resourceName: ''
});
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}}/backend/:appId/storage/:backendEnvironmentName',
headers: {'content-type': 'application/json'},
data: {resourceConfig: {Permissions: '', ServiceName: ''}, resourceName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"resourceConfig":{"Permissions":"","ServiceName":""},"resourceName":""}'
};
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 = @{ @"resourceConfig": @{ @"Permissions": @"", @"ServiceName": @"" },
@"resourceName": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"]
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}}/backend/:appId/storage/:backendEnvironmentName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName",
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([
'resourceConfig' => [
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]),
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}}/backend/:appId/storage/:backendEnvironmentName', [
'body' => '{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'resourceConfig' => [
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'resourceConfig' => [
'Permissions' => '',
'ServiceName' => ''
],
'resourceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName');
$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}}/backend/:appId/storage/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/backend/:appId/storage/:backendEnvironmentName", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"
payload = {
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName"
payload <- "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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}}/backend/:appId/storage/:backendEnvironmentName")
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 \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\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/backend/:appId/storage/:backendEnvironmentName') do |req|
req.body = "{\n \"resourceConfig\": {\n \"Permissions\": \"\",\n \"ServiceName\": \"\"\n },\n \"resourceName\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName";
let payload = json!({
"resourceConfig": json!({
"Permissions": "",
"ServiceName": ""
}),
"resourceName": ""
});
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}}/backend/:appId/storage/:backendEnvironmentName \
--header 'content-type: application/json' \
--data '{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}'echo '{
"resourceConfig": {
"Permissions": "",
"ServiceName": ""
},
"resourceName": ""
}' | \
http POST {{baseUrl}}/backend/:appId/storage/:backendEnvironmentName \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "resourceConfig": {\n "Permissions": "",\n "ServiceName": ""\n },\n "resourceName": ""\n}' \
--output-document \
- {{baseUrl}}/backend/:appId/storage/:backendEnvironmentNameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"resourceConfig": [
"Permissions": "",
"ServiceName": ""
],
"resourceName": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backend/:appId/storage/:backendEnvironmentName")! 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()