wecube-plugins-terminal

POST Create Asset

{{baseUrl}}/terminal/v1/mgmt-assets

BODY json

[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets");

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/terminal/v1/mgmt-assets" {:content-type :json
                                                                    :form-params [{:id ""
                                                                                   :name ""
                                                                                   :display_name ""
                                                                                   :ip_address ""
                                                                                   :port 0
                                                                                   :username ""
                                                                                   :password ""
                                                                                   :description ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/mgmt-assets"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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}}/terminal/v1/mgmt-assets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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/terminal/v1/mgmt-assets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/mgmt-assets")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/mgmt-assets")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]);

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

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

xhr.open('POST', '{{baseUrl}}/terminal/v1/mgmt-assets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "display_name": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": "",\n    "description": ""\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets")
  .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/terminal/v1/mgmt-assets',
  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([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/terminal/v1/mgmt-assets');

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

req.type('json');
req.send([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]);

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}]'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"id": @"", @"name": @"", @"display_name": @"", @"ip_address": @"", @"port": @0, @"username": @"", @"password": @"", @"description": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/mgmt-assets"]
                                                       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}}/terminal/v1/mgmt-assets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets",
  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([
    [
        'id' => '',
        'name' => '',
        'display_name' => '',
        'ip_address' => '',
        'port' => 0,
        'username' => '',
        'password' => '',
        'description' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/terminal/v1/mgmt-assets', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'display_name' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => '',
    'description' => ''
  ]
]));

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

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

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'display_name' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => '',
    'description' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/mgmt-assets');
$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}}/terminal/v1/mgmt-assets' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

conn.request("POST", "/baseUrl/terminal/v1/mgmt-assets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets"

payload = [
    {
        "id": "",
        "name": "",
        "display_name": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": "",
        "description": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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}}/terminal/v1/mgmt-assets")

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

require 'faraday'

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

response = conn.post('/baseUrl/terminal/v1/mgmt-assets') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "display_name": "",
            "ip_address": "",
            "port": 0,
            "username": "",
            "password": "",
            "description": ""
        })
    );

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/terminal/v1/mgmt-assets \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

echo '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/mgmt-assets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "display_name": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": "",\n    "description": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/mgmt-assets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One Asset

{{baseUrl}}/terminal/v1/mgmt-assets/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/terminal/v1/mgmt-assets/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/mgmt-assets/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/mgmt-assets/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

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

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

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

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

}

DELETE /baseUrl/terminal/v1/mgmt-assets/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id'
};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/mgmt-assets/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id'
};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/mgmt-assets/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/mgmt-assets/:id" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/mgmt-assets/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/terminal/v1/mgmt-assets/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/mgmt-assets/:id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/terminal/v1/mgmt-assets/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/mgmt-assets/:id

http DELETE {{baseUrl}}/terminal/v1/mgmt-assets/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/mgmt-assets/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Download File from an Asset

{{baseUrl}}/terminal/v1/assets/:id/file

QUERY PARAMS

path

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/assets/:id/file?path=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/assets/:id/file" {:query-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/assets/:id/file?path="

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/assets/:id/file?path=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/assets/:id/file?path="

	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/terminal/v1/assets/:id/file?path= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/assets/:id/file?path="))
    .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}}/terminal/v1/assets/:id/file?path=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .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}}/terminal/v1/assets/:id/file?path=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/terminal/v1/assets/:id/file',
  params: {path: ''}
};

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/file?path=';
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}}/terminal/v1/assets/:id/file?path=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/assets/:id/file?path=',
  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}}/terminal/v1/assets/:id/file',
  qs: {path: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/assets/:id/file');

req.query({
  path: ''
});

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}}/terminal/v1/assets/:id/file',
  params: {path: ''}
};

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

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/file?path=';
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}}/terminal/v1/assets/:id/file?path="]
                                                       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}}/terminal/v1/assets/:id/file?path=" in

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

 "{{baseUrl}}/terminal/v1/assets/:id/file?path=",
  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}}/terminal/v1/assets/:id/file?path=');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/assets/:id/file');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'path' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/assets/:id/file');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'path' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/assets/:id/file?path=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/assets/:id/file?path=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/assets/:id/file?path=")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/assets/:id/file"

querystring = {"path":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/assets/:id/file"

queryString <- list(path = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/assets/:id/file?path=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/assets/:id/file') do |req|
  req.params['path'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/assets/:id/file";

    let querystring = [
        ("path", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/terminal/v1/assets/:id/file?path='

http GET '{{baseUrl}}/terminal/v1/assets/:id/file?path='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/terminal/v1/assets/:id/file?path='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/assets/:id/file?path=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One Asset

{{baseUrl}}/terminal/v1/mgmt-assets/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/mgmt-assets/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/mgmt-assets/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

	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/terminal/v1/mgmt-assets/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets/:id"))
    .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}}/terminal/v1/mgmt-assets/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .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}}/terminal/v1/mgmt-assets/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id'};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
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}}/terminal/v1/mgmt-assets/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/mgmt-assets/:id',
  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}}/terminal/v1/mgmt-assets/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id'};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
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}}/terminal/v1/mgmt-assets/:id"]
                                                       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}}/terminal/v1/mgmt-assets/:id" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets/:id",
  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}}/terminal/v1/mgmt-assets/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/mgmt-assets/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/mgmt-assets/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/mgmt-assets/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/mgmt-assets/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id";

    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}}/terminal/v1/mgmt-assets/:id

http GET {{baseUrl}}/terminal/v1/mgmt-assets/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/mgmt-assets/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "host000001",
    "name": "host-app-1",
    "display_name": "subsys01-unit01-host-app-1",
    "ip_address": "127.0.0.1",
    "port": 22,
    "username": "root",
    "password": "password",
    "description": "app-1 of something"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List All Asset

{{baseUrl}}/terminal/v1/mgmt-assets

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/mgmt-assets")

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/mgmt-assets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets"

	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/terminal/v1/mgmt-assets HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets"))
    .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}}/terminal/v1/mgmt-assets")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/mgmt-assets")
  .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}}/terminal/v1/mgmt-assets');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/mgmt-assets'};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
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}}/terminal/v1/mgmt-assets',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/mgmt-assets',
  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}}/terminal/v1/mgmt-assets'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/mgmt-assets');

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}}/terminal/v1/mgmt-assets'};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
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}}/terminal/v1/mgmt-assets"]
                                                       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}}/terminal/v1/mgmt-assets" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets",
  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}}/terminal/v1/mgmt-assets');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/mgmt-assets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/mgmt-assets")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/mgmt-assets")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/mgmt-assets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets";

    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}}/terminal/v1/mgmt-assets

http GET {{baseUrl}}/terminal/v1/mgmt-assets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Assets

{{baseUrl}}/terminal/v1/assets

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/assets");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/assets")

require "http/client"

url = "{{baseUrl}}/terminal/v1/assets"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/assets"

	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/terminal/v1/assets HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/assets"))
    .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}}/terminal/v1/assets")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/assets")
  .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}}/terminal/v1/assets');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/assets'};

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

const url = '{{baseUrl}}/terminal/v1/assets';
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}}/terminal/v1/assets',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/assets',
  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}}/terminal/v1/assets'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/assets');

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}}/terminal/v1/assets'};

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

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

const url = '{{baseUrl}}/terminal/v1/assets';
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}}/terminal/v1/assets"]
                                                       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}}/terminal/v1/assets" in

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

 "{{baseUrl}}/terminal/v1/assets",
  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}}/terminal/v1/assets');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/assets');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/assets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/assets' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/assets")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/assets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/assets"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/assets")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/assets') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/terminal/v1/assets

http GET {{baseUrl}}/terminal/v1/assets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/assets

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Permissions of an Asset

{{baseUrl}}/terminal/v1/assets/:id/permissions

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/assets/:id/permissions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/assets/:id/permissions")

require "http/client"

url = "{{baseUrl}}/terminal/v1/assets/:id/permissions"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/assets/:id/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/assets/:id/permissions"

	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/terminal/v1/assets/:id/permissions HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/assets/:id/permissions"))
    .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}}/terminal/v1/assets/:id/permissions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/assets/:id/permissions")
  .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}}/terminal/v1/assets/:id/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/terminal/v1/assets/:id/permissions'
};

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/permissions';
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}}/terminal/v1/assets/:id/permissions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/assets/:id/permissions")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/assets/:id/permissions',
  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}}/terminal/v1/assets/:id/permissions'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/assets/:id/permissions');

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}}/terminal/v1/assets/:id/permissions'
};

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

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/permissions';
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}}/terminal/v1/assets/:id/permissions"]
                                                       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}}/terminal/v1/assets/:id/permissions" in

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

 "{{baseUrl}}/terminal/v1/assets/:id/permissions",
  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}}/terminal/v1/assets/:id/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/assets/:id/permissions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/assets/:id/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/assets/:id/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/assets/:id/permissions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/assets/:id/permissions")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/assets/:id/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/assets/:id/permissions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/assets/:id/permissions")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/assets/:id/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/assets/:id/permissions";

    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}}/terminal/v1/assets/:id/permissions

http GET {{baseUrl}}/terminal/v1/assets/:id/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/assets/:id/permissions

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": [
    [
      "execute",
      "download"
    ]
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List View-Only Assets

{{baseUrl}}/terminal/v1/view-assets

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/view-assets");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/view-assets")

require "http/client"

url = "{{baseUrl}}/terminal/v1/view-assets"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/view-assets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/view-assets"

	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/terminal/v1/view-assets HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/view-assets"))
    .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}}/terminal/v1/view-assets")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/view-assets")
  .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}}/terminal/v1/view-assets');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/view-assets'};

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

const url = '{{baseUrl}}/terminal/v1/view-assets';
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}}/terminal/v1/view-assets',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/view-assets")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/view-assets',
  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}}/terminal/v1/view-assets'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/view-assets');

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}}/terminal/v1/view-assets'};

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

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

const url = '{{baseUrl}}/terminal/v1/view-assets';
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}}/terminal/v1/view-assets"]
                                                       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}}/terminal/v1/view-assets" in

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

 "{{baseUrl}}/terminal/v1/view-assets",
  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}}/terminal/v1/view-assets');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/view-assets');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/view-assets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/view-assets' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/view-assets")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/view-assets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/view-assets"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/view-assets")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/view-assets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/view-assets";

    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}}/terminal/v1/view-assets

http GET {{baseUrl}}/terminal/v1/view-assets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/view-assets

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update Assets

{{baseUrl}}/terminal/v1/mgmt-assets

BODY json

[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets");

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/terminal/v1/mgmt-assets" {:content-type :json
                                                                     :form-params [{:id ""
                                                                                    :name ""
                                                                                    :display_name ""
                                                                                    :ip_address ""
                                                                                    :port 0
                                                                                    :username ""
                                                                                    :password ""
                                                                                    :description ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/mgmt-assets"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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}}/terminal/v1/mgmt-assets");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/mgmt-assets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/mgmt-assets")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/mgmt-assets")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "display_name": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": "",\n    "description": ""\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/mgmt-assets',
  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([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets');

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

req.type('json');
req.send([
  {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      display_name: '',
      ip_address: '',
      port: 0,
      username: '',
      password: '',
      description: ''
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}]'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{ @"id": @"", @"name": @"", @"display_name": @"", @"ip_address": @"", @"port": @0, @"username": @"", @"password": @"", @"description": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/mgmt-assets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/mgmt-assets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'name' => '',
        'display_name' => '',
        'ip_address' => '',
        'port' => 0,
        'username' => '',
        'password' => '',
        'description' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'display_name' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => '',
    'description' => ''
  ]
]));

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

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

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'display_name' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => '',
    'description' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/mgmt-assets');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/mgmt-assets' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/terminal/v1/mgmt-assets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets"

payload = [
    {
        "id": "",
        "name": "",
        "display_name": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": "",
        "description": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/mgmt-assets")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"

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

require 'faraday'

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

response = conn.patch('/baseUrl/terminal/v1/mgmt-assets') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"display_name\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\",\n    \"description\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "display_name": "",
            "ip_address": "",
            "port": 0,
            "username": "",
            "password": "",
            "description": ""
        })
    );

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/mgmt-assets \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]'

echo '[
  {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/mgmt-assets \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "display_name": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": "",\n    "description": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/mgmt-assets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One Asset

{{baseUrl}}/terminal/v1/mgmt-assets/:id

BODY json

{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/mgmt-assets/:id");

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  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/terminal/v1/mgmt-assets/:id" {:content-type :json
                                                                         :form-params {:id ""
                                                                                       :name ""
                                                                                       :display_name ""
                                                                                       :ip_address ""
                                                                                       :port 0
                                                                                       :username ""
                                                                                       :password ""
                                                                                       :description ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/mgmt-assets/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/mgmt-assets/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/mgmt-assets/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 140

{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/mgmt-assets/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  name: '',
  display_name: '',
  ip_address: '',
  port: 0,
  username: '',
  password: '',
  description: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
};

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "name": "",\n  "display_name": "",\n  "ip_address": "",\n  "port": 0,\n  "username": "",\n  "password": "",\n  "description": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/mgmt-assets/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/mgmt-assets/:id',
  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({
  id: '',
  name: '',
  display_name: '',
  ip_address: '',
  port: 0,
  username: '',
  password: '',
  description: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets/:id');

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

req.type('json');
req.send({
  id: '',
  name: '',
  display_name: '',
  ip_address: '',
  port: 0,
  username: '',
  password: '',
  description: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/mgmt-assets/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    display_name: '',
    ip_address: '',
    port: 0,
    username: '',
    password: '',
    description: ''
  }
};

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

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

const url = '{{baseUrl}}/terminal/v1/mgmt-assets/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","display_name":"","ip_address":"","port":0,"username":"","password":"","description":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @"",
                              @"name": @"",
                              @"display_name": @"",
                              @"ip_address": @"",
                              @"port": @0,
                              @"username": @"",
                              @"password": @"",
                              @"description": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/mgmt-assets/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/mgmt-assets/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}" in

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

 "{{baseUrl}}/terminal/v1/mgmt-assets/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => '',
    'name' => '',
    'display_name' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => '',
    'description' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/terminal/v1/mgmt-assets/:id', [
  'body' => '{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'name' => '',
  'display_name' => '',
  'ip_address' => '',
  'port' => 0,
  'username' => '',
  'password' => '',
  'description' => ''
]));

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

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

append(json_encode([
  'id' => '',
  'name' => '',
  'display_name' => '',
  'ip_address' => '',
  'port' => 0,
  'username' => '',
  'password' => '',
  'description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/mgmt-assets/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/mgmt-assets/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/mgmt-assets/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/terminal/v1/mgmt-assets/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

payload = {
    "id": "",
    "name": "",
    "display_name": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": "",
    "description": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/mgmt-assets/:id"

payload <- "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/mgmt-assets/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/terminal/v1/mgmt-assets/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"display_name\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\",\n  \"description\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/mgmt-assets/:id";

    let payload = json!({
        "id": "",
        "name": "",
        "display_name": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": "",
        "description": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/mgmt-assets/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}'

echo '{
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/mgmt-assets/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "name": "",\n  "display_name": "",\n  "ip_address": "",\n  "port": 0,\n  "username": "",\n  "password": "",\n  "description": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/mgmt-assets/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "name": "",
  "display_name": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": "",
  "description": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/mgmt-assets/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "host000001",
    "name": "host-app-1",
    "display_name": "subsys01-unit01-host-app-1",
    "ip_address": "127.0.0.1",
    "port": 22,
    "username": "root",
    "password": "password",
    "description": "app-1 of something"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Upload File to an Asset

{{baseUrl}}/terminal/v1/assets/:id/file

QUERY PARAMS

path

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/assets/:id/file?path=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/terminal/v1/assets/:id/file" {:query-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/assets/:id/file?path="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/assets/:id/file?path="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/assets/:id/file?path=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/assets/:id/file?path="

	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/terminal/v1/assets/:id/file?path= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/assets/:id/file?path="))
    .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}}/terminal/v1/assets/:id/file?path=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .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}}/terminal/v1/assets/:id/file?path=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/assets/:id/file',
  params: {path: ''}
};

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/file?path=';
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}}/terminal/v1/assets/:id/file?path=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/assets/:id/file?path=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/assets/:id/file?path=',
  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}}/terminal/v1/assets/:id/file',
  qs: {path: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/terminal/v1/assets/:id/file');

req.query({
  path: ''
});

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}}/terminal/v1/assets/:id/file',
  params: {path: ''}
};

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

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

const url = '{{baseUrl}}/terminal/v1/assets/:id/file?path=';
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}}/terminal/v1/assets/:id/file?path="]
                                                       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}}/terminal/v1/assets/:id/file?path=" in

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

 "{{baseUrl}}/terminal/v1/assets/:id/file?path=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/terminal/v1/assets/:id/file?path=');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/assets/:id/file');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'path' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/assets/:id/file');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'path' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/assets/:id/file?path=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/assets/:id/file?path=' -Method POST

import http.client

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

payload = ""

conn.request("POST", "/baseUrl/terminal/v1/assets/:id/file?path=", payload)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/assets/:id/file"

querystring = {"path":""}

payload = ""

response = requests.post(url, data=payload, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/assets/:id/file"

queryString <- list(path = "")

payload <- ""

response <- VERB("POST", url, body = payload, query = queryString, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/assets/:id/file?path=")

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_body

require 'faraday'

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

response = conn.post('/baseUrl/terminal/v1/assets/:id/file') do |req|
  req.params['path'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/assets/:id/file";

    let querystring = [
        ("path", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/terminal/v1/assets/:id/file?path='

http POST '{{baseUrl}}/terminal/v1/assets/:id/file?path='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/terminal/v1/assets/:id/file?path='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/assets/:id/file?path=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get Session replay file

{{baseUrl}}/terminal/v1/session-records/:id/file

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/session-records/:id/file");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/session-records/:id/file")

require "http/client"

url = "{{baseUrl}}/terminal/v1/session-records/:id/file"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/session-records/:id/file");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/session-records/:id/file"

	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/terminal/v1/session-records/:id/file HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/session-records/:id/file")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/session-records/:id/file"))
    .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}}/terminal/v1/session-records/:id/file")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/session-records/:id/file")
  .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}}/terminal/v1/session-records/:id/file');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/terminal/v1/session-records/:id/file'
};

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

const url = '{{baseUrl}}/terminal/v1/session-records/:id/file';
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}}/terminal/v1/session-records/:id/file',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/session-records/:id/file")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/session-records/:id/file',
  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}}/terminal/v1/session-records/:id/file'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/session-records/:id/file');

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}}/terminal/v1/session-records/:id/file'
};

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

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

const url = '{{baseUrl}}/terminal/v1/session-records/:id/file';
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}}/terminal/v1/session-records/:id/file"]
                                                       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}}/terminal/v1/session-records/:id/file" in

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

 "{{baseUrl}}/terminal/v1/session-records/:id/file",
  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}}/terminal/v1/session-records/:id/file');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/session-records/:id/file');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/session-records/:id/file');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/session-records/:id/file' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/session-records/:id/file' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/session-records/:id/file")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/session-records/:id/file"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/session-records/:id/file"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/session-records/:id/file")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/session-records/:id/file') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/session-records/:id/file";

    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}}/terminal/v1/session-records/:id/file

http GET {{baseUrl}}/terminal/v1/session-records/:id/file

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/session-records/:id/file

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/session-records/:id/file")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List File-transfer records

{{baseUrl}}/terminal/v1/transfer-records

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/transfer-records");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/transfer-records")

require "http/client"

url = "{{baseUrl}}/terminal/v1/transfer-records"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/transfer-records");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/transfer-records"

	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/terminal/v1/transfer-records HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/transfer-records"))
    .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}}/terminal/v1/transfer-records")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/transfer-records")
  .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}}/terminal/v1/transfer-records');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/transfer-records'};

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

const url = '{{baseUrl}}/terminal/v1/transfer-records';
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}}/terminal/v1/transfer-records',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/transfer-records")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/transfer-records',
  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}}/terminal/v1/transfer-records'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/transfer-records');

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}}/terminal/v1/transfer-records'};

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

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

const url = '{{baseUrl}}/terminal/v1/transfer-records';
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}}/terminal/v1/transfer-records"]
                                                       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}}/terminal/v1/transfer-records" in

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

 "{{baseUrl}}/terminal/v1/transfer-records",
  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}}/terminal/v1/transfer-records');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/transfer-records');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/transfer-records' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/transfer-records' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/transfer-records")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/transfer-records"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/transfer-records"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/transfer-records")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/transfer-records') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/transfer-records";

    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}}/terminal/v1/transfer-records

http GET {{baseUrl}}/terminal/v1/transfer-records

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/transfer-records

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Session records

{{baseUrl}}/terminal/v1/session-records

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/session-records");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/session-records")

require "http/client"

url = "{{baseUrl}}/terminal/v1/session-records"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/session-records");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/session-records"

	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/terminal/v1/session-records HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/session-records"))
    .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}}/terminal/v1/session-records")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/session-records")
  .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}}/terminal/v1/session-records');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/session-records'};

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

const url = '{{baseUrl}}/terminal/v1/session-records';
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}}/terminal/v1/session-records',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/session-records")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/session-records',
  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}}/terminal/v1/session-records'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/session-records');

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}}/terminal/v1/session-records'};

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

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

const url = '{{baseUrl}}/terminal/v1/session-records';
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}}/terminal/v1/session-records"]
                                                       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}}/terminal/v1/session-records" in

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

 "{{baseUrl}}/terminal/v1/session-records",
  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}}/terminal/v1/session-records');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/session-records');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/session-records' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/session-records' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/session-records")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/session-records"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/session-records"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/session-records")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/session-records') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/session-records";

    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}}/terminal/v1/session-records

http GET {{baseUrl}}/terminal/v1/session-records

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/session-records

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Create Bookmarks

{{baseUrl}}/terminal/v1/bookmarks

BODY json

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks");

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/terminal/v1/bookmarks" {:content-type :json
                                                                  :form-params [{:id 0
                                                                                 :name ""
                                                                                 :description ""
                                                                                 :expression ""
                                                                                 :roles {:owner []
                                                                                         :executor []}}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/bookmarks"),
    Content = new StringContent("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/bookmarks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks"

	payload := strings.NewReader("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")

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

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

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

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

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

}

POST /baseUrl/terminal/v1/bookmarks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/bookmarks")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/bookmarks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/bookmarks")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {
      owner: [],
      executor: []
    }
  }
]);

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

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

xhr.open('POST', '{{baseUrl}}/terminal/v1/bookmarks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "expression": "",\n    "roles": {\n      "owner": [],\n      "executor": []\n    }\n  }\n]'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks")
  .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/terminal/v1/bookmarks',
  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([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {owner: [], executor: []}
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ],
  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}}/terminal/v1/bookmarks');

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

req.type('json');
req.send([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {
      owner: [],
      executor: []
    }
  }
]);

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}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}]'
};

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 = @[ @{ @"id": @0, @"name": @"", @"description": @"", @"expression": @"", @"roles": @{ @"owner": @[  ], @"executor": @[  ] } } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/bookmarks"]
                                                       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}}/terminal/v1/bookmarks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/bookmarks",
  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([
    [
        'id' => 0,
        'name' => '',
        'description' => '',
        'expression' => '',
        'roles' => [
                'owner' => [
                                
                ],
                'executor' => [
                                
                ]
        ]
    ]
  ]),
  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}}/terminal/v1/bookmarks', [
  'body' => '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'expression' => '',
    'roles' => [
        'owner' => [
                
        ],
        'executor' => [
                
        ]
    ]
  ]
]));

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

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

append(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'expression' => '',
    'roles' => [
        'owner' => [
                
        ],
        'executor' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/bookmarks');
$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}}/terminal/v1/bookmarks' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

conn.request("POST", "/baseUrl/terminal/v1/bookmarks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks"

payload = [
    {
        "id": 0,
        "name": "",
        "description": "",
        "expression": "",
        "roles": {
            "owner": [],
            "executor": []
        }
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks"

payload <- "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks")

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

require 'faraday'

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

response = conn.post('/baseUrl/terminal/v1/bookmarks') do |req|
  req.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = (
        json!({
            "id": 0,
            "name": "",
            "description": "",
            "expression": "",
            "roles": json!({
                "owner": (),
                "executor": ()
            })
        })
    );

    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}}/terminal/v1/bookmarks \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

echo '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/bookmarks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "expression": "",\n    "roles": {\n      "owner": [],\n      "executor": []\n    }\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": [
      "owner": [],
      "executor": []
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One Bookmark

{{baseUrl}}/terminal/v1/bookmarks/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/terminal/v1/bookmarks/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/bookmarks/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks/:id"

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

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

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

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

}

DELETE /baseUrl/terminal/v1/bookmarks/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/bookmarks/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/bookmarks/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/bookmarks/:id'};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/bookmarks/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/bookmarks/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/bookmarks/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/bookmarks/:id');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/bookmarks/:id'};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/bookmarks/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/bookmarks/:id" in

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

 "{{baseUrl}}/terminal/v1/bookmarks/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/terminal/v1/bookmarks/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/bookmarks/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/terminal/v1/bookmarks/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks/:id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/terminal/v1/bookmarks/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/bookmarks/:id

http DELETE {{baseUrl}}/terminal/v1/bookmarks/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/bookmarks/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One Bookmark

{{baseUrl}}/terminal/v1/bookmarks/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/bookmarks/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/bookmarks/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks/:id"

	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/terminal/v1/bookmarks/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/bookmarks/:id"))
    .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}}/terminal/v1/bookmarks/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .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}}/terminal/v1/bookmarks/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/bookmarks/:id'};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
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}}/terminal/v1/bookmarks/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/bookmarks/:id',
  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}}/terminal/v1/bookmarks/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/bookmarks/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/bookmarks/:id'};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
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}}/terminal/v1/bookmarks/:id"]
                                                       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}}/terminal/v1/bookmarks/:id" in

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

 "{{baseUrl}}/terminal/v1/bookmarks/:id",
  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}}/terminal/v1/bookmarks/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/bookmarks/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/bookmarks/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/bookmarks/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/terminal/v1/bookmarks/:id

http GET {{baseUrl}}/terminal/v1/bookmarks/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks/:id

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": 1,
    "name": "sys01 hosts",
    "description": "hosts of sys01 that created",
    "expression": "wecmdb:host_resource_instance"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Bookmarks

{{baseUrl}}/terminal/v1/bookmarks

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/bookmarks")

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks"

	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/terminal/v1/bookmarks HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/bookmarks"))
    .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}}/terminal/v1/bookmarks")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/bookmarks")
  .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}}/terminal/v1/bookmarks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/bookmarks'};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
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}}/terminal/v1/bookmarks',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/bookmarks',
  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}}/terminal/v1/bookmarks'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/bookmarks');

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}}/terminal/v1/bookmarks'};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
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}}/terminal/v1/bookmarks"]
                                                       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}}/terminal/v1/bookmarks" in

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

 "{{baseUrl}}/terminal/v1/bookmarks",
  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}}/terminal/v1/bookmarks');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/bookmarks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/bookmarks")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/bookmarks') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/terminal/v1/bookmarks

http GET {{baseUrl}}/terminal/v1/bookmarks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update Bookmarks

{{baseUrl}}/terminal/v1/bookmarks

BODY json

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks");

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/terminal/v1/bookmarks" {:content-type :json
                                                                   :form-params [{:id 0
                                                                                  :name ""
                                                                                  :description ""
                                                                                  :expression ""
                                                                                  :roles {:owner []
                                                                                          :executor []}}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/bookmarks"),
    Content = new StringContent("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/bookmarks");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks"

	payload := strings.NewReader("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/bookmarks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/bookmarks")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/bookmarks"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/bookmarks")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {
      owner: [],
      executor: []
    }
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/bookmarks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "expression": "",\n    "roles": {\n      "owner": [],\n      "executor": []\n    }\n  }\n]'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/bookmarks',
  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([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {owner: [], executor: []}
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/bookmarks');

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

req.type('json');
req.send([
  {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {
      owner: [],
      executor: []
    }
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      expression: '',
      roles: {owner: [], executor: []}
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}]'
};

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 = @[ @{ @"id": @0, @"name": @"", @"description": @"", @"expression": @"", @"roles": @{ @"owner": @[  ], @"executor": @[  ] } } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/bookmarks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/bookmarks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/bookmarks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => 0,
        'name' => '',
        'description' => '',
        'expression' => '',
        'roles' => [
                'owner' => [
                                
                ],
                'executor' => [
                                
                ]
        ]
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/bookmarks', [
  'body' => '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'expression' => '',
    'roles' => [
        'owner' => [
                
        ],
        'executor' => [
                
        ]
    ]
  ]
]));

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

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

append(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'expression' => '',
    'roles' => [
        'owner' => [
                
        ],
        'executor' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/bookmarks');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/bookmarks' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

conn.request("PATCH", "/baseUrl/terminal/v1/bookmarks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks"

payload = [
    {
        "id": 0,
        "name": "",
        "description": "",
        "expression": "",
        "roles": {
            "owner": [],
            "executor": []
        }
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks"

payload <- "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"

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

require 'faraday'

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

response = conn.patch('/baseUrl/terminal/v1/bookmarks') do |req|
  req.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"expression\": \"\",\n    \"roles\": {\n      \"owner\": [],\n      \"executor\": []\n    }\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = (
        json!({
            "id": 0,
            "name": "",
            "description": "",
            "expression": "",
            "roles": json!({
                "owner": (),
                "executor": ()
            })
        })
    );

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/bookmarks \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]'

echo '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
      "owner": [],
      "executor": []
    }
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/bookmarks \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "expression": "",\n    "roles": {\n      "owner": [],\n      "executor": []\n    }\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": [
      "owner": [],
      "executor": []
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/bookmarks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One Bookmark

{{baseUrl}}/terminal/v1/bookmarks/:id

BODY json

{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/bookmarks/:id");

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  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/terminal/v1/bookmarks/:id" {:content-type :json
                                                                       :form-params {:id 0
                                                                                     :name ""
                                                                                     :description ""
                                                                                     :expression ""
                                                                                     :roles {:owner []
                                                                                             :executor []}}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/bookmarks/:id"),
    Content = new StringContent("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\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}}/terminal/v1/bookmarks/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/bookmarks/:id"

	payload := strings.NewReader("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/bookmarks/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 122

{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/bookmarks/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/bookmarks/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\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  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}")
  .asString();

const data = JSON.stringify({
  id: 0,
  name: '',
  description: '',
  expression: '',
  roles: {
    owner: [],
    executor: []
  }
});

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

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

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/bookmarks/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {owner: [], executor: []}
  }
};

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/bookmarks/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": 0,\n  "name": "",\n  "description": "",\n  "expression": "",\n  "roles": {\n    "owner": [],\n    "executor": []\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  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/bookmarks/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/bookmarks/:id',
  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({
  id: 0,
  name: '',
  description: '',
  expression: '',
  roles: {owner: [], executor: []}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks/:id',
  headers: {'content-type': 'application/json'},
  body: {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {owner: [], executor: []}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/bookmarks/:id');

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

req.type('json');
req.send({
  id: 0,
  name: '',
  description: '',
  expression: '',
  roles: {
    owner: [],
    executor: []
  }
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/bookmarks/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: 0,
    name: '',
    description: '',
    expression: '',
    roles: {owner: [], executor: []}
  }
};

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

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

const url = '{{baseUrl}}/terminal/v1/bookmarks/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":0,"name":"","description":"","expression":"","roles":{"owner":[],"executor":[]}}'
};

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 = @{ @"id": @0,
                              @"name": @"",
                              @"description": @"",
                              @"expression": @"",
                              @"roles": @{ @"owner": @[  ], @"executor": @[  ] } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/bookmarks/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/bookmarks/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}" in

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

 "{{baseUrl}}/terminal/v1/bookmarks/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => 0,
    'name' => '',
    'description' => '',
    'expression' => '',
    'roles' => [
        'owner' => [
                
        ],
        'executor' => [
                
        ]
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/bookmarks/:id', [
  'body' => '{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 0,
  'name' => '',
  'description' => '',
  'expression' => '',
  'roles' => [
    'owner' => [
        
    ],
    'executor' => [
        
    ]
  ]
]));

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

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

append(json_encode([
  'id' => 0,
  'name' => '',
  'description' => '',
  'expression' => '',
  'roles' => [
    'owner' => [
        
    ],
    'executor' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/bookmarks/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/bookmarks/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/bookmarks/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}'

import http.client

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

payload = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}"

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

conn.request("PATCH", "/baseUrl/terminal/v1/bookmarks/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/bookmarks/:id"

payload = {
    "id": 0,
    "name": "",
    "description": "",
    "expression": "",
    "roles": {
        "owner": [],
        "executor": []
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/bookmarks/:id"

payload <- "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/bookmarks/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/terminal/v1/bookmarks/:id') do |req|
  req.body = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"roles\": {\n    \"owner\": [],\n    \"executor\": []\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": 0,
        "name": "",
        "description": "",
        "expression": "",
        "roles": json!({
            "owner": (),
            "executor": ()
        })
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/bookmarks/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}'

echo '{
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": {
    "owner": [],
    "executor": []
  }
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/bookmarks/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": 0,\n  "name": "",\n  "description": "",\n  "expression": "",\n  "roles": {\n    "owner": [],\n    "executor": []\n  }\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/bookmarks/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": 0,
  "name": "",
  "description": "",
  "expression": "",
  "roles": [
    "owner": [],
    "executor": []
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/bookmarks/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": 1,
    "name": "sys01 hosts",
    "description": "hosts of sys01 that created",
    "expression": "wecmdb:host_resource_instance"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get SSH Connection(websocket)

{{baseUrl}}/terminal/v1/ssh

HEADERS

Connection

Upgrade

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/ssh");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "connection: ");
headers = curl_slist_append(headers, "upgrade: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/ssh" {:headers {:connection ""
                                                                     :upgrade ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/ssh"
headers = HTTP::Headers{
  "connection" => ""
  "upgrade" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/ssh");
var request = new RestRequest("", Method.Get);
request.AddHeader("connection", "");
request.AddHeader("upgrade", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/ssh"

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

	req.Header.Add("connection", "")
	req.Header.Add("upgrade", "")

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

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

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

}

GET /baseUrl/terminal/v1/ssh HTTP/1.1
Connection: 
Upgrade: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/ssh")
  .setHeader("connection", "")
  .setHeader("upgrade", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/ssh"))
    .header("connection", "")
    .header("upgrade", "")
    .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}}/terminal/v1/ssh")
  .get()
  .addHeader("connection", "")
  .addHeader("upgrade", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/ssh")
  .header("connection", "")
  .header("upgrade", "")
  .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}}/terminal/v1/ssh');
xhr.setRequestHeader('connection', '');
xhr.setRequestHeader('upgrade', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/terminal/v1/ssh',
  headers: {connection: '', upgrade: ''}
};

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

const url = '{{baseUrl}}/terminal/v1/ssh';
const options = {method: 'GET', headers: {connection: '', upgrade: ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/ssh',
  method: 'GET',
  headers: {
    connection: '',
    upgrade: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/ssh")
  .get()
  .addHeader("connection", "")
  .addHeader("upgrade", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/ssh',
  headers: {
    connection: '',
    upgrade: ''
  }
};

const req = http.request(options, function (res) {
  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}}/terminal/v1/ssh',
  headers: {connection: '', upgrade: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/ssh');

req.headers({
  connection: '',
  upgrade: ''
});

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}}/terminal/v1/ssh',
  headers: {connection: '', upgrade: ''}
};

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

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

const url = '{{baseUrl}}/terminal/v1/ssh';
const options = {method: 'GET', headers: {connection: '', upgrade: ''}};

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

#import 

NSDictionary *headers = @{ @"connection": @"",
                           @"upgrade": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/ssh"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/ssh" in
let headers = Header.add_list (Header.init ()) [
  ("connection", "");
  ("upgrade", "");
] in

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

 "{{baseUrl}}/terminal/v1/ssh",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "connection: ",
    "upgrade: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/terminal/v1/ssh', [
  'headers' => [
    'connection' => '',
    'upgrade' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/ssh');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'connection' => '',
  'upgrade' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/ssh');
$request->setRequestMethod('GET');
$request->setHeaders([
  'connection' => '',
  'upgrade' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("upgrade", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/ssh' -Method GET -Headers $headers

$headers=@{}
$headers.Add("upgrade", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/ssh' -Method GET -Headers $headers

import http.client

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

headers = {
    'connection': "",
    'upgrade': ""
}

conn.request("GET", "/baseUrl/terminal/v1/ssh", headers=headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/ssh"

headers = {
    "connection": "",
    "upgrade": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/ssh"

response <- VERB("GET", url, add_headers('connection' = '', 'upgrade' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/ssh")

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

request = Net::HTTP::Get.new(url)
request["connection"] = ''
request["upgrade"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/ssh') do |req|
  req.headers['connection'] = ''
  req.headers['upgrade'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("connection", "".parse().unwrap());
    headers.insert("upgrade", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/terminal/v1/ssh \
  --header 'connection: ' \
  --header 'upgrade: '

http GET {{baseUrl}}/terminal/v1/ssh \
  connection:'' \
  upgrade:''

wget --quiet \
  --method GET \
  --header 'connection: ' \
  --header 'upgrade: ' \
  --output-document \
  - {{baseUrl}}/terminal/v1/ssh

import Foundation

let headers = [
  "connection": "",
  "upgrade": ""
]

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

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

dataTask.resume()

POST Create JumpServers

{{baseUrl}}/terminal/v1/jumpservers

BODY json

[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers");

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/terminal/v1/jumpservers" {:content-type :json
                                                                    :form-params [{:id ""
                                                                                   :name ""
                                                                                   :scope ""
                                                                                   :ip_address ""
                                                                                   :port 0
                                                                                   :username ""
                                                                                   :password ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/jumpservers"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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}}/terminal/v1/jumpservers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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/terminal/v1/jumpservers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/jumpservers")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/jumpservers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/jumpservers")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]);

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

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

xhr.open('POST', '{{baseUrl}}/terminal/v1/jumpservers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "scope": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": ""\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers")
  .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/terminal/v1/jumpservers',
  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([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ],
  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}}/terminal/v1/jumpservers');

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

req.type('json');
req.send([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]);

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}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}]'
};

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 = @[ @{ @"id": @"", @"name": @"", @"scope": @"", @"ip_address": @"", @"port": @0, @"username": @"", @"password": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/jumpservers"]
                                                       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}}/terminal/v1/jumpservers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/jumpservers",
  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([
    [
        'id' => '',
        'name' => '',
        'scope' => '',
        'ip_address' => '',
        'port' => 0,
        'username' => '',
        'password' => ''
    ]
  ]),
  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}}/terminal/v1/jumpservers', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'scope' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => ''
  ]
]));

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

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

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'scope' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/jumpservers');
$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}}/terminal/v1/jumpservers' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

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

conn.request("POST", "/baseUrl/terminal/v1/jumpservers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers"

payload = [
    {
        "id": "",
        "name": "",
        "scope": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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}}/terminal/v1/jumpservers")

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

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

require 'faraday'

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

response = conn.post('/baseUrl/terminal/v1/jumpservers') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = (
        json!({
            "id": "",
            "name": "",
            "scope": "",
            "ip_address": "",
            "port": 0,
            "username": "",
            "password": ""
        })
    );

    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}}/terminal/v1/jumpservers \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

echo '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/jumpservers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "scope": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  ]
] as [String : Any]

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

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One JumpServer

{{baseUrl}}/terminal/v1/jumpservers/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/terminal/v1/jumpservers/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/jumpservers/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers/:id"

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

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

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

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

}

DELETE /baseUrl/terminal/v1/jumpservers/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/jumpservers/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/jumpservers/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id'
};

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

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/jumpservers/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/jumpservers/:id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id'
};

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

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

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/jumpservers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/jumpservers/:id" in

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

 "{{baseUrl}}/terminal/v1/jumpservers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/terminal/v1/jumpservers/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/jumpservers/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/terminal/v1/jumpservers/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/jumpservers/:id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/terminal/v1/jumpservers/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/jumpservers/:id

http DELETE {{baseUrl}}/terminal/v1/jumpservers/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/jumpservers/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One JumpServer

{{baseUrl}}/terminal/v1/jumpservers/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/jumpservers/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"

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

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

var client = new RestClient("{{baseUrl}}/terminal/v1/jumpservers/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers/:id"

	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/terminal/v1/jumpservers/:id HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/jumpservers/:id"))
    .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}}/terminal/v1/jumpservers/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .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}}/terminal/v1/jumpservers/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/jumpservers/:id'};

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

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
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}}/terminal/v1/jumpservers/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/jumpservers/:id',
  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}}/terminal/v1/jumpservers/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/jumpservers/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/jumpservers/:id'};

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

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

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
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}}/terminal/v1/jumpservers/:id"]
                                                       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}}/terminal/v1/jumpservers/:id" in

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

 "{{baseUrl}}/terminal/v1/jumpservers/:id",
  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}}/terminal/v1/jumpservers/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/jumpservers/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/jumpservers/:id")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/jumpservers/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/jumpservers/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/terminal/v1/jumpservers/:id

http GET {{baseUrl}}/terminal/v1/jumpservers/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers/:id

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "jserver-01",
    "name": "j-dev01",
    "scope": "10.0.0.0/16;10.1.0.0/16",
    "ip_address": "127.0.0.1",
    "port": 22,
    "username": "root",
    "password": "password"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List JumpServers

{{baseUrl}}/terminal/v1/jumpservers

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/terminal/v1/jumpservers")

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers"

	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/terminal/v1/jumpservers HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/jumpservers"))
    .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}}/terminal/v1/jumpservers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/jumpservers")
  .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}}/terminal/v1/jumpservers');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/jumpservers'};

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
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}}/terminal/v1/jumpservers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/jumpservers',
  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}}/terminal/v1/jumpservers'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/jumpservers');

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}}/terminal/v1/jumpservers'};

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

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
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}}/terminal/v1/jumpservers"]
                                                       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}}/terminal/v1/jumpservers" in

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

 "{{baseUrl}}/terminal/v1/jumpservers",
  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}}/terminal/v1/jumpservers');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/jumpservers' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/terminal/v1/jumpservers")

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

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

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/jumpservers")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/terminal/v1/jumpservers') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/terminal/v1/jumpservers

http GET {{baseUrl}}/terminal/v1/jumpservers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers

import Foundation

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update JumpServers

{{baseUrl}}/terminal/v1/jumpservers

BODY json

[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers");

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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/terminal/v1/jumpservers" {:content-type :json
                                                                     :form-params [{:id ""
                                                                                    :name ""
                                                                                    :scope ""
                                                                                    :ip_address ""
                                                                                    :port 0
                                                                                    :username ""
                                                                                    :password ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/jumpservers"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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}}/terminal/v1/jumpservers");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/jumpservers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/jumpservers")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/jumpservers"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/jumpservers")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/jumpservers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ]
};

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "name": "",\n    "scope": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": ""\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  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/jumpservers',
  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([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/jumpservers');

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

req.type('json');
req.send([
  {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: '',
      name: '',
      scope: '',
      ip_address: '',
      port: 0,
      username: '',
      password: ''
    }
  ]
};

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

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

const url = '{{baseUrl}}/terminal/v1/jumpservers';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}]'
};

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 = @[ @{ @"id": @"", @"name": @"", @"scope": @"", @"ip_address": @"", @"port": @0, @"username": @"", @"password": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/jumpservers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/jumpservers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/terminal/v1/jumpservers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'name' => '',
        'scope' => '',
        'ip_address' => '',
        'port' => 0,
        'username' => '',
        'password' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/jumpservers', [
  'body' => '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'name' => '',
    'scope' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => ''
  ]
]));

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

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

append(json_encode([
  [
    'id' => '',
    'name' => '',
    'scope' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/jumpservers');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/jumpservers' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/terminal/v1/jumpservers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers"

payload = [
    {
        "id": "",
        "name": "",
        "scope": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers"

payload <- "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/jumpservers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/jumpservers') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"name\": \"\",\n    \"scope\": \"\",\n    \"ip_address\": \"\",\n    \"port\": 0,\n    \"username\": \"\",\n    \"password\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/jumpservers";

    let payload = (
        json!({
            "id": "",
            "name": "",
            "scope": "",
            "ip_address": "",
            "port": 0,
            "username": "",
            "password": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/jumpservers \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]'

echo '[
  {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/jumpservers \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "name": "",\n    "scope": "",\n    "ip_address": "",\n    "port": 0,\n    "username": "",\n    "password": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/jumpservers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One JumpServer

{{baseUrl}}/terminal/v1/jumpservers/:id

BODY json

{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/jumpservers/:id");

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  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/jumpservers/:id" {:content-type :json
                                                                         :form-params {:id ""
                                                                                       :name ""
                                                                                       :scope ""
                                                                                       :ip_address ""
                                                                                       :port 0
                                                                                       :username ""
                                                                                       :password ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/jumpservers/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\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}}/terminal/v1/jumpservers/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/jumpservers/:id"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/jumpservers/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/jumpservers/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/jumpservers/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\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  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  name: '',
  scope: '',
  ip_address: '',
  port: 0,
  username: '',
  password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/jumpservers/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "name": "",\n  "scope": "",\n  "ip_address": "",\n  "port": 0,\n  "username": "",\n  "password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/jumpservers/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/jumpservers/:id',
  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({
  id: '',
  name: '',
  scope: '',
  ip_address: '',
  port: 0,
  username: '',
  password: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/jumpservers/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: '',
  name: '',
  scope: '',
  ip_address: '',
  port: 0,
  username: '',
  password: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/jumpservers/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    scope: '',
    ip_address: '',
    port: 0,
    username: '',
    password: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/jumpservers/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","scope":"","ip_address":"","port":0,"username":"","password":""}'
};

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 = @{ @"id": @"",
                              @"name": @"",
                              @"scope": @"",
                              @"ip_address": @"",
                              @"port": @0,
                              @"username": @"",
                              @"password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/jumpservers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/jumpservers/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/jumpservers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => '',
    'name' => '',
    'scope' => '',
    'ip_address' => '',
    'port' => 0,
    'username' => '',
    'password' => ''
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/jumpservers/:id', [
  'body' => '{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'name' => '',
  'scope' => '',
  'ip_address' => '',
  'port' => 0,
  'username' => '',
  'password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => '',
  'name' => '',
  'scope' => '',
  'ip_address' => '',
  'port' => 0,
  'username' => '',
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/jumpservers/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/jumpservers/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/jumpservers/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/jumpservers/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/jumpservers/:id"

payload = {
    "id": "",
    "name": "",
    "scope": "",
    "ip_address": "",
    "port": 0,
    "username": "",
    "password": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/jumpservers/:id"

payload <- "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/jumpservers/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/jumpservers/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"scope\": \"\",\n  \"ip_address\": \"\",\n  \"port\": 0,\n  \"username\": \"\",\n  \"password\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/jumpservers/:id";

    let payload = json!({
        "id": "",
        "name": "",
        "scope": "",
        "ip_address": "",
        "port": 0,
        "username": "",
        "password": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/jumpservers/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}'

echo '{
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/jumpservers/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "name": "",\n  "scope": "",\n  "ip_address": "",\n  "port": 0,\n  "username": "",\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/jumpservers/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "name": "",
  "scope": "",
  "ip_address": "",
  "port": 0,
  "username": "",
  "password": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/jumpservers/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "jserver-01",
    "name": "j-dev01",
    "scope": "10.0.0.0/16;10.1.0.0/16",
    "ip_address": "127.0.0.1",
    "port": 22,
    "username": "root",
    "password": "password"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Login

{{baseUrl}}/terminal/v1/login

BODY json

{
  "username": "",
  "password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/login");

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  \"username\": \"\",\n  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/login" {:content-type :json
                                                              :form-params {:username ""
                                                                            :password ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/login"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"username\": \"\",\n  \"password\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/login"),
    Content = new StringContent("{\n  \"username\": \"\",\n  \"password\": \"\"\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}}/terminal/v1/login");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"username\": \"\",\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/login"

	payload := strings.NewReader("{\n  \"username\": \"\",\n  \"password\": \"\"\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/terminal/v1/login HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "username": "",
  "password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/login")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"username\": \"\",\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/login"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"username\": \"\",\n  \"password\": \"\"\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  \"username\": \"\",\n  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/login")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/login")
  .header("content-type", "application/json")
  .body("{\n  \"username\": \"\",\n  \"password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  username: '',
  password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/login');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/login',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/login',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "username": "",\n  "password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"username\": \"\",\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/login")
  .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/terminal/v1/login',
  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({username: '', password: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/login',
  headers: {'content-type': 'application/json'},
  body: {username: '', password: ''},
  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}}/terminal/v1/login');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  username: '',
  password: ''
});

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}}/terminal/v1/login',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":""}'
};

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 = @{ @"username": @"",
                              @"password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/login"]
                                                       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}}/terminal/v1/login" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"username\": \"\",\n  \"password\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/login",
  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([
    'username' => '',
    'password' => ''
  ]),
  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}}/terminal/v1/login', [
  'body' => '{
  "username": "",
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/login');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'username' => '',
  'password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'username' => '',
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/login');
$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}}/terminal/v1/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"username\": \"\",\n  \"password\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/login", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/login"

payload = {
    "username": "",
    "password": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/login"

payload <- "{\n  \"username\": \"\",\n  \"password\": \"\"\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}}/terminal/v1/login")

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  \"username\": \"\",\n  \"password\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/login') do |req|
  req.body = "{\n  \"username\": \"\",\n  \"password\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/login";

    let payload = json!({
        "username": "",
        "password": ""
    });

    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}}/terminal/v1/login \
  --header 'content-type: application/json' \
  --data '{
  "username": "",
  "password": ""
}'

echo '{
  "username": "",
  "password": ""
}' |  \
  http POST {{baseUrl}}/terminal/v1/login \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "username": "",\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/login

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "username": "",
  "password": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "ops, username or password error, login deny"
}

GET Refresh Login

{{baseUrl}}/terminal/v1/refresh-token

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/refresh-token");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/refresh-token")

require "http/client"

url = "{{baseUrl}}/terminal/v1/refresh-token"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/refresh-token"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/refresh-token");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/refresh-token"

	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/terminal/v1/refresh-token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/refresh-token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/refresh-token"))
    .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}}/terminal/v1/refresh-token")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/refresh-token")
  .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}}/terminal/v1/refresh-token');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/refresh-token'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/refresh-token';
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}}/terminal/v1/refresh-token',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/refresh-token")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/refresh-token',
  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}}/terminal/v1/refresh-token'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/refresh-token');

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}}/terminal/v1/refresh-token'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/refresh-token';
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}}/terminal/v1/refresh-token"]
                                                       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}}/terminal/v1/refresh-token" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/refresh-token",
  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}}/terminal/v1/refresh-token');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/refresh-token');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/refresh-token');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/refresh-token' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/refresh-token' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/refresh-token")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/refresh-token"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/refresh-token"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/refresh-token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/refresh-token') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/refresh-token";

    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}}/terminal/v1/refresh-token

http GET {{baseUrl}}/terminal/v1/refresh-token

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/refresh-token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/refresh-token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/menus");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/menus")

require "http/client"

url = "{{baseUrl}}/terminal/v1/menus"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/menus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/menus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/menus"

	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/terminal/v1/menus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/menus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/menus"))
    .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}}/terminal/v1/menus")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/menus")
  .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}}/terminal/v1/menus');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/menus';
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}}/terminal/v1/menus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/menus")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/menus',
  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}}/terminal/v1/menus'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/menus');

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}}/terminal/v1/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/menus';
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}}/terminal/v1/menus"]
                                                       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}}/terminal/v1/menus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/menus",
  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}}/terminal/v1/menus');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/menus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/menus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/menus' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/menus' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/menus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/menus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/menus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/menus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/menus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/menus";

    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}}/terminal/v1/menus

http GET {{baseUrl}}/terminal/v1/menus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/menus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/menus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/user-menus");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/user-menus")

require "http/client"

url = "{{baseUrl}}/terminal/v1/user-menus"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/user-menus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/user-menus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/user-menus"

	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/terminal/v1/user-menus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/user-menus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/user-menus"))
    .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}}/terminal/v1/user-menus")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/user-menus")
  .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}}/terminal/v1/user-menus');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/user-menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/user-menus';
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}}/terminal/v1/user-menus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/user-menus")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/user-menus',
  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}}/terminal/v1/user-menus'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/user-menus');

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}}/terminal/v1/user-menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/user-menus';
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}}/terminal/v1/user-menus"]
                                                       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}}/terminal/v1/user-menus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/user-menus",
  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}}/terminal/v1/user-menus');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/user-menus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/user-menus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/user-menus' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/user-menus' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/user-menus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/user-menus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/user-menus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/user-menus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/user-menus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/user-menus";

    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}}/terminal/v1/user-menus

http GET {{baseUrl}}/terminal/v1/user-menus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/user-menus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/user-menus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Create Permissions

{{baseUrl}}/terminal/v1/permissions

BODY json

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions");

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/permissions" {:content-type :json
                                                                    :form-params [{:id 0
                                                                                   :name ""
                                                                                   :description ""
                                                                                   :auth_upload 0
                                                                                   :auth_download 0
                                                                                   :auth_execute 0
                                                                                   :enabled 0
                                                                                   :assets []
                                                                                   :roles []}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions"),
    Content = new StringContent("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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}}/terminal/v1/permissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions"

	payload := strings.NewReader("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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/terminal/v1/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 184

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/permissions")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/permissions")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/permissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "auth_upload": 0,\n    "auth_download": 0,\n    "auth_execute": 0,\n    "enabled": 0,\n    "assets": [],\n    "roles": []\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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions")
  .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/terminal/v1/permissions',
  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([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ],
  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}}/terminal/v1/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]);

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}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}]'
};

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 = @[ @{ @"id": @0, @"name": @"", @"description": @"", @"auth_upload": @0, @"auth_download": @0, @"auth_execute": @0, @"enabled": @0, @"assets": @[  ], @"roles": @[  ] } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/permissions"]
                                                       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}}/terminal/v1/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions",
  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([
    [
        'id' => 0,
        'name' => '',
        'description' => '',
        'auth_upload' => 0,
        'auth_download' => 0,
        'auth_execute' => 0,
        'enabled' => 0,
        'assets' => [
                
        ],
        'roles' => [
                
        ]
    ]
  ]),
  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}}/terminal/v1/permissions', [
  'body' => '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'auth_upload' => 0,
    'auth_download' => 0,
    'auth_execute' => 0,
    'enabled' => 0,
    'assets' => [
        
    ],
    'roles' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'auth_upload' => 0,
    'auth_download' => 0,
    'auth_execute' => 0,
    'enabled' => 0,
    'assets' => [
        
    ],
    'roles' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/permissions');
$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}}/terminal/v1/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions"

payload = [
    {
        "id": 0,
        "name": "",
        "description": "",
        "auth_upload": 0,
        "auth_download": 0,
        "auth_execute": 0,
        "enabled": 0,
        "assets": [],
        "roles": []
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions"

payload <- "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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}}/terminal/v1/permissions")

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/permissions') do |req|
  req.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions";

    let payload = (
        json!({
            "id": 0,
            "name": "",
            "description": "",
            "auth_upload": 0,
            "auth_download": 0,
            "auth_execute": 0,
            "enabled": 0,
            "assets": (),
            "roles": ()
        })
    );

    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}}/terminal/v1/permissions \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

echo '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/permissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "auth_upload": 0,\n    "auth_download": 0,\n    "auth_execute": 0,\n    "enabled": 0,\n    "assets": [],\n    "roles": []\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One Permission

{{baseUrl}}/terminal/v1/permissions/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/terminal/v1/permissions/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/permissions/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/terminal/v1/permissions/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/permissions/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/permissions/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/permissions/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/permissions/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/permissions/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/permissions/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/permissions/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/permissions/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/terminal/v1/permissions/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/permissions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/permissions/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/terminal/v1/permissions/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/permissions/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/terminal/v1/permissions/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/permissions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/terminal/v1/permissions/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/permissions/:id

http DELETE {{baseUrl}}/terminal/v1/permissions/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One Permission

{{baseUrl}}/terminal/v1/permissions/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/permissions/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/permissions/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions/:id"

	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/terminal/v1/permissions/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/permissions/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions/:id"))
    .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}}/terminal/v1/permissions/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/permissions/:id")
  .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}}/terminal/v1/permissions/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/permissions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
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}}/terminal/v1/permissions/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/permissions/:id',
  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}}/terminal/v1/permissions/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/permissions/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/permissions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
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}}/terminal/v1/permissions/:id"]
                                                       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}}/terminal/v1/permissions/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions/:id",
  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}}/terminal/v1/permissions/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/permissions/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/permissions/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/permissions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/permissions/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions/:id";

    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}}/terminal/v1/permissions/:id

http GET {{baseUrl}}/terminal/v1/permissions/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": 1,
    "name": "",
    "description": "",
    "auth_upload": 1,
    "auth_download": 1,
    "auth_execute": 1,
    "enabled": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Permissions

{{baseUrl}}/terminal/v1/permissions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/permissions")

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions"

	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/terminal/v1/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions"))
    .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}}/terminal/v1/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/permissions")
  .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}}/terminal/v1/permissions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/permissions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions';
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}}/terminal/v1/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/permissions',
  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}}/terminal/v1/permissions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/permissions');

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}}/terminal/v1/permissions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions';
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}}/terminal/v1/permissions"]
                                                       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}}/terminal/v1/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions",
  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}}/terminal/v1/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/permissions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions";

    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}}/terminal/v1/permissions

http GET {{baseUrl}}/terminal/v1/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One Permission

{{baseUrl}}/terminal/v1/permissions/:id

BODY json

{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions/:id");

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  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/permissions/:id" {:content-type :json
                                                                         :form-params {:id 0
                                                                                       :name ""
                                                                                       :description ""
                                                                                       :auth_upload 0
                                                                                       :auth_download 0
                                                                                       :auth_execute 0
                                                                                       :enabled 0
                                                                                       :assets []
                                                                                       :roles []}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions/:id"),
    Content = new StringContent("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\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}}/terminal/v1/permissions/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions/:id"

	payload := strings.NewReader("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/permissions/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 158

{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/permissions/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\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  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/permissions/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}")
  .asString();

const data = JSON.stringify({
  id: 0,
  name: '',
  description: '',
  auth_upload: 0,
  auth_download: 0,
  auth_execute: 0,
  enabled: 0,
  assets: [],
  roles: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/permissions/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/permissions/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": 0,\n  "name": "",\n  "description": "",\n  "auth_upload": 0,\n  "auth_download": 0,\n  "auth_execute": 0,\n  "enabled": 0,\n  "assets": [],\n  "roles": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/permissions/:id',
  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({
  id: 0,
  name: '',
  description: '',
  auth_upload: 0,
  auth_download: 0,
  auth_execute: 0,
  enabled: 0,
  assets: [],
  roles: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions/:id',
  headers: {'content-type': 'application/json'},
  body: {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/permissions/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: 0,
  name: '',
  description: '',
  auth_upload: 0,
  auth_download: 0,
  auth_execute: 0,
  enabled: 0,
  assets: [],
  roles: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions/:id',
  headers: {'content-type': 'application/json'},
  data: {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}'
};

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 = @{ @"id": @0,
                              @"name": @"",
                              @"description": @"",
                              @"auth_upload": @0,
                              @"auth_download": @0,
                              @"auth_execute": @0,
                              @"enabled": @0,
                              @"assets": @[  ],
                              @"roles": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/permissions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/permissions/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => 0,
    'name' => '',
    'description' => '',
    'auth_upload' => 0,
    'auth_download' => 0,
    'auth_execute' => 0,
    'enabled' => 0,
    'assets' => [
        
    ],
    'roles' => [
        
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/permissions/:id', [
  'body' => '{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 0,
  'name' => '',
  'description' => '',
  'auth_upload' => 0,
  'auth_download' => 0,
  'auth_execute' => 0,
  'enabled' => 0,
  'assets' => [
    
  ],
  'roles' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => 0,
  'name' => '',
  'description' => '',
  'auth_upload' => 0,
  'auth_download' => 0,
  'auth_execute' => 0,
  'enabled' => 0,
  'assets' => [
    
  ],
  'roles' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/permissions/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/permissions/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/permissions/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions/:id"

payload = {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions/:id"

payload <- "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/permissions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/permissions/:id') do |req|
  req.body = "{\n  \"id\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"auth_upload\": 0,\n  \"auth_download\": 0,\n  \"auth_execute\": 0,\n  \"enabled\": 0,\n  \"assets\": [],\n  \"roles\": []\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions/:id";

    let payload = json!({
        "id": 0,
        "name": "",
        "description": "",
        "auth_upload": 0,
        "auth_download": 0,
        "auth_execute": 0,
        "enabled": 0,
        "assets": (),
        "roles": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/permissions/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}'

echo '{
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/permissions/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": 0,\n  "name": "",\n  "description": "",\n  "auth_upload": 0,\n  "auth_download": 0,\n  "auth_execute": 0,\n  "enabled": 0,\n  "assets": [],\n  "roles": []\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": 0,
  "name": "",
  "description": "",
  "auth_upload": 0,
  "auth_download": 0,
  "auth_execute": 0,
  "enabled": 0,
  "assets": [],
  "roles": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": 1,
    "name": "",
    "description": "",
    "auth_upload": 1,
    "auth_download": 1,
    "auth_execute": 1,
    "enabled": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update Permissions

{{baseUrl}}/terminal/v1/permissions

BODY json

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/permissions");

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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/permissions" {:content-type :json
                                                                     :form-params [{:id 0
                                                                                    :name ""
                                                                                    :description ""
                                                                                    :auth_upload 0
                                                                                    :auth_download 0
                                                                                    :auth_execute 0
                                                                                    :enabled 0
                                                                                    :assets []
                                                                                    :roles []}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/permissions"),
    Content = new StringContent("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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}}/terminal/v1/permissions");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/permissions"

	payload := strings.NewReader("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 184

[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/permissions")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/permissions"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/permissions")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/permissions';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/permissions',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "auth_upload": 0,\n    "auth_download": 0,\n    "auth_execute": 0,\n    "enabled": 0,\n    "assets": [],\n    "roles": []\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  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/permissions")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/permissions',
  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([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  body: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: 0,
    name: '',
    description: '',
    auth_upload: 0,
    auth_download: 0,
    auth_execute: 0,
    enabled: 0,
    assets: [],
    roles: []
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/permissions',
  headers: {'content-type': 'application/json'},
  data: [
    {
      id: 0,
      name: '',
      description: '',
      auth_upload: 0,
      auth_download: 0,
      auth_execute: 0,
      enabled: 0,
      assets: [],
      roles: []
    }
  ]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/permissions';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":0,"name":"","description":"","auth_upload":0,"auth_download":0,"auth_execute":0,"enabled":0,"assets":[],"roles":[]}]'
};

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 = @[ @{ @"id": @0, @"name": @"", @"description": @"", @"auth_upload": @0, @"auth_download": @0, @"auth_execute": @0, @"enabled": @0, @"assets": @[  ], @"roles": @[  ] } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => 0,
        'name' => '',
        'description' => '',
        'auth_upload' => 0,
        'auth_download' => 0,
        'auth_execute' => 0,
        'enabled' => 0,
        'assets' => [
                
        ],
        'roles' => [
                
        ]
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/permissions', [
  'body' => '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/permissions');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'auth_upload' => 0,
    'auth_download' => 0,
    'auth_execute' => 0,
    'enabled' => 0,
    'assets' => [
        
    ],
    'roles' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => 0,
    'name' => '',
    'description' => '',
    'auth_upload' => 0,
    'auth_download' => 0,
    'auth_execute' => 0,
    'enabled' => 0,
    'assets' => [
        
    ],
    'roles' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/permissions');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/permissions' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/permissions' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/permissions"

payload = [
    {
        "id": 0,
        "name": "",
        "description": "",
        "auth_upload": 0,
        "auth_download": 0,
        "auth_execute": 0,
        "enabled": 0,
        "assets": [],
        "roles": []
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/permissions"

payload <- "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/permissions') do |req|
  req.body = "[\n  {\n    \"id\": 0,\n    \"name\": \"\",\n    \"description\": \"\",\n    \"auth_upload\": 0,\n    \"auth_download\": 0,\n    \"auth_execute\": 0,\n    \"enabled\": 0,\n    \"assets\": [],\n    \"roles\": []\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/permissions";

    let payload = (
        json!({
            "id": 0,
            "name": "",
            "description": "",
            "auth_upload": 0,
            "auth_download": 0,
            "auth_execute": 0,
            "enabled": 0,
            "assets": (),
            "roles": ()
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/permissions \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]'

echo '[
  {
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/permissions \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": 0,\n    "name": "",\n    "description": "",\n    "auth_upload": 0,\n    "auth_download": 0,\n    "auth_execute": 0,\n    "enabled": 0,\n    "assets": [],\n    "roles": []\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/permissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": 0,
    "name": "",
    "description": "",
    "auth_upload": 0,
    "auth_download": 0,
    "auth_execute": 0,
    "enabled": 0,
    "assets": [],
    "roles": []
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Create Roles

{{baseUrl}}/terminal/v1/roles

BODY json

[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles");

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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/roles" {:content-type :json
                                                              :form-params [{:id ""
                                                                             :description ""
                                                                             :is_system ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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/terminal/v1/roles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68

[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/roles")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/roles")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    description: '',
    is_system: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/roles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  data: [{id: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","description":"","is_system":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "description": "",\n    "is_system": ""\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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles")
  .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/terminal/v1/roles',
  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([{id: '', description: '', is_system: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  body: [{id: '', description: '', is_system: ''}],
  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}}/terminal/v1/roles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    description: '',
    is_system: ''
  }
]);

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}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  data: [{id: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","description":"","is_system":""}]'
};

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 = @[ @{ @"id": @"", @"description": @"", @"is_system": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles"]
                                                       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}}/terminal/v1/roles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles",
  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([
    [
        'id' => '',
        'description' => '',
        'is_system' => ''
    ]
  ]),
  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}}/terminal/v1/roles', [
  'body' => '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'description' => '',
    'is_system' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'description' => '',
    'is_system' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/roles');
$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}}/terminal/v1/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/roles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles"

payload = [
    {
        "id": "",
        "description": "",
        "is_system": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles"

payload <- "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/roles")

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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/roles') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles";

    let payload = (
        json!({
            "id": "",
            "description": "",
            "is_system": ""
        })
    );

    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}}/terminal/v1/roles \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

echo '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/roles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "description": "",\n    "is_system": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "description": "",
    "is_system": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One Role

{{baseUrl}}/terminal/v1/roles/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/terminal/v1/roles/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/roles/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/terminal/v1/roles/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/roles/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/roles/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/roles/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/roles/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/roles/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/roles/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/roles/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/roles/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/terminal/v1/roles/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/terminal/v1/roles/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/terminal/v1/roles/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/roles/:id

http DELETE {{baseUrl}}/terminal/v1/roles/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One Role

{{baseUrl}}/terminal/v1/roles/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/roles/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/roles/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id"

	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/terminal/v1/roles/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/roles/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id"))
    .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}}/terminal/v1/roles/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/roles/:id")
  .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}}/terminal/v1/roles/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id';
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}}/terminal/v1/roles/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id',
  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}}/terminal/v1/roles/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/roles/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id';
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}}/terminal/v1/roles/:id"]
                                                       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}}/terminal/v1/roles/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id",
  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}}/terminal/v1/roles/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/roles/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/roles/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id";

    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}}/terminal/v1/roles/:id

http GET {{baseUrl}}/terminal/v1/roles/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "config_manager",
    "description": "role of config manager",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get Role Menus

{{baseUrl}}/terminal/v1/roles/:id/menus

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id/menus");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/roles/:id/menus")

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id/menus"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id/menus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/roles/:id/menus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id/menus"

	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/terminal/v1/roles/:id/menus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/roles/:id/menus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id/menus"))
    .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}}/terminal/v1/roles/:id/menus")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/roles/:id/menus")
  .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}}/terminal/v1/roles/:id/menus');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id/menus';
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}}/terminal/v1/roles/:id/menus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/menus")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id/menus',
  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}}/terminal/v1/roles/:id/menus'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/roles/:id/menus');

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}}/terminal/v1/roles/:id/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id/menus';
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}}/terminal/v1/roles/:id/menus"]
                                                       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}}/terminal/v1/roles/:id/menus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id/menus",
  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}}/terminal/v1/roles/:id/menus');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id/menus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id/menus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles/:id/menus' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id/menus' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/roles/:id/menus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id/menus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id/menus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles/:id/menus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/roles/:id/menus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id/menus";

    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}}/terminal/v1/roles/:id/menus

http GET {{baseUrl}}/terminal/v1/roles/:id/menus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id/menus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id/menus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get Role Users

{{baseUrl}}/terminal/v1/roles/:id/users

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/roles/:id/users")

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id/users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/roles/:id/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id/users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/terminal/v1/roles/:id/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/roles/:id/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id/users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/roles/:id/users")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/terminal/v1/roles/:id/users');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles/:id/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id/users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/roles/:id/users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles/:id/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles/:id/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/roles/:id/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/terminal/v1/roles/:id/users');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles/:id/users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id/users' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/roles/:id/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id/users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles/:id/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/roles/:id/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/terminal/v1/roles/:id/users

http GET {{baseUrl}}/terminal/v1/roles/:id/users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Roles

{{baseUrl}}/terminal/v1/roles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/roles")

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles"

	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/terminal/v1/roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles"))
    .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}}/terminal/v1/roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/roles")
  .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}}/terminal/v1/roles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles';
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}}/terminal/v1/roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles',
  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}}/terminal/v1/roles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/roles');

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}}/terminal/v1/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles';
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}}/terminal/v1/roles"]
                                                       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}}/terminal/v1/roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles",
  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}}/terminal/v1/roles');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles";

    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}}/terminal/v1/roles

http GET {{baseUrl}}/terminal/v1/roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Set Role Menus

{{baseUrl}}/terminal/v1/roles/:id/menus

BODY json

[
  {}
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id/menus");

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  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/roles/:id/menus" {:content-type :json
                                                                        :form-params [{}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id/menus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {}\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id/menus"),
    Content = new StringContent("[\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}}/terminal/v1/roles/:id/menus");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id/menus"

	payload := strings.NewReader("[\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/terminal/v1/roles/:id/menus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/roles/:id/menus")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id/menus"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\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  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/menus")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/roles/:id/menus")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/roles/:id/menus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles/:id/menus',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id/menus';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles/:id/menus',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/menus")
  .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/terminal/v1/roles/:id/menus',
  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([{}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles/:id/menus',
  headers: {'content-type': 'application/json'},
  body: [{}],
  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}}/terminal/v1/roles/:id/menus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {}
]);

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}}/terminal/v1/roles/:id/menus',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id/menus';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles/:id/menus"]
                                                       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}}/terminal/v1/roles/:id/menus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id/menus",
  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([
    [
        
    ]
  ]),
  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}}/terminal/v1/roles/:id/menus', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id/menus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id/menus');
$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}}/terminal/v1/roles/:id/menus' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id/menus' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {}\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/roles/:id/menus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id/menus"

payload = [{}]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id/menus"

payload <- "[\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}}/terminal/v1/roles/:id/menus")

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  {}\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/roles/:id/menus') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id/menus";

    let payload = (json!({}));

    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}}/terminal/v1/roles/:id/menus \
  --header 'content-type: application/json' \
  --data '[
  {}
]'

echo '[
  {}
]' |  \
  http POST {{baseUrl}}/terminal/v1/roles/:id/menus \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id/menus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id/menus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Set Role Users

{{baseUrl}}/terminal/v1/roles/:id/users

BODY json

[
  {}
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id/users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/roles/:id/users" {:content-type :json
                                                                        :form-params [{}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {}\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id/users"),
    Content = new StringContent("[\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}}/terminal/v1/roles/:id/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id/users"

	payload := strings.NewReader("[\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/terminal/v1/roles/:id/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/roles/:id/users")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\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  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/roles/:id/users")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/roles/:id/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles/:id/users',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id/users';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles/:id/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id/users',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([{}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/roles/:id/users',
  headers: {'content-type': 'application/json'},
  body: [{}],
  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}}/terminal/v1/roles/:id/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {}
]);

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}}/terminal/v1/roles/:id/users',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id/users';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles/:id/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/roles/:id/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        
    ]
  ]),
  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}}/terminal/v1/roles/:id/users', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id/users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id/users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/roles/:id/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {}\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/roles/:id/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id/users"

payload = [{}]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id/users"

payload <- "[\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}}/terminal/v1/roles/:id/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {}\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/roles/:id/users') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id/users";

    let payload = (json!({}));

    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}}/terminal/v1/roles/:id/users \
  --header 'content-type: application/json' \
  --data '[
  {}
]'

echo '[
  {}
]' |  \
  http POST {{baseUrl}}/terminal/v1/roles/:id/users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One Role

{{baseUrl}}/terminal/v1/roles/:id

BODY json

{
  "id": "",
  "description": "",
  "is_system": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles/:id");

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  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/roles/:id" {:content-type :json
                                                                   :form-params {:id ""
                                                                                 :description ""
                                                                                 :is_system ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\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}}/terminal/v1/roles/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles/:id"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/roles/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "id": "",
  "description": "",
  "is_system": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/roles/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\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  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/roles/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  description: '',
  is_system: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/roles/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', description: '', is_system: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","description":"","is_system":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "description": "",\n  "is_system": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles/:id',
  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({id: '', description: '', is_system: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles/:id',
  headers: {'content-type': 'application/json'},
  body: {id: '', description: '', is_system: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/roles/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: '',
  description: '',
  is_system: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', description: '', is_system: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","description":"","is_system":""}'
};

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 = @{ @"id": @"",
                              @"description": @"",
                              @"is_system": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/roles/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => '',
    'description' => '',
    'is_system' => ''
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/roles/:id', [
  'body' => '{
  "id": "",
  "description": "",
  "is_system": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'description' => '',
  'is_system' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => '',
  'description' => '',
  'is_system' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/roles/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/roles/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "description": "",
  "is_system": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "description": "",
  "is_system": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/roles/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles/:id"

payload = {
    "id": "",
    "description": "",
    "is_system": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles/:id"

payload <- "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/roles/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles/:id";

    let payload = json!({
        "id": "",
        "description": "",
        "is_system": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/roles/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "description": "",
  "is_system": ""
}'

echo '{
  "id": "",
  "description": "",
  "is_system": ""
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/roles/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "description": "",\n  "is_system": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "description": "",
  "is_system": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "config_manager",
    "description": "role of config manager",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update Roles

{{baseUrl}}/terminal/v1/roles

BODY json

[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/roles");

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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/roles" {:content-type :json
                                                               :form-params [{:id ""
                                                                              :description ""
                                                                              :is_system ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/roles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/roles"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/roles");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/roles"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/roles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68

[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/roles")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/roles"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/roles")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    description: '',
    is_system: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/roles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  data: [{id: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/roles';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","description":"","is_system":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/roles',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "description": "",\n    "is_system": ""\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  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/roles")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/roles',
  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([{id: '', description: '', is_system: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  body: [{id: '', description: '', is_system: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/roles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    description: '',
    is_system: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/roles',
  headers: {'content-type': 'application/json'},
  data: [{id: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/roles';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","description":"","is_system":""}]'
};

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 = @[ @{ @"id": @"", @"description": @"", @"is_system": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/roles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'description' => '',
        'is_system' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/roles', [
  'body' => '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/roles');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'description' => '',
    'is_system' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'description' => '',
    'is_system' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/roles');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/roles' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/roles' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/roles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/roles"

payload = [
    {
        "id": "",
        "description": "",
        "is_system": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/roles"

payload <- "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/roles') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/roles";

    let payload = (
        json!({
            "id": "",
            "description": "",
            "is_system": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/roles \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]'

echo '[
  {
    "id": "",
    "description": "",
    "is_system": ""
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/roles \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "description": "",\n    "is_system": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/roles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "description": "",
    "is_system": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Create Users

{{baseUrl}}/terminal/v1/users

BODY json

[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/users" {:content-type :json
                                                              :form-params [{:id ""
                                                                             :display_name ""
                                                                             :password ""
                                                                             :description ""
                                                                             :is_system ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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/terminal/v1/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/users")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/users")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    display_name: '',
    password: '',
    description: '',
    is_system: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', display_name: '', password: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","display_name":"","password":"","description":"","is_system":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "display_name": "",\n    "password": "",\n    "description": "",\n    "is_system": ""\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  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([{id: '', display_name: '', password: '', description: '', is_system: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  body: [{id: '', display_name: '', password: '', description: '', is_system: ''}],
  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}}/terminal/v1/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    display_name: '',
    password: '',
    description: '',
    is_system: ''
  }
]);

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}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', display_name: '', password: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","display_name":"","password":"","description":"","is_system":""}]'
};

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 = @[ @{ @"id": @"", @"display_name": @"", @"password": @"", @"description": @"", @"is_system": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'display_name' => '',
        'password' => '',
        'description' => '',
        'is_system' => ''
    ]
  ]),
  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}}/terminal/v1/users', [
  'body' => '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'display_name' => '',
    'password' => '',
    'description' => '',
    'is_system' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'display_name' => '',
    'password' => '',
    'description' => '',
    'is_system' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users"

payload = [
    {
        "id": "",
        "display_name": "",
        "password": "",
        "description": "",
        "is_system": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users"

payload <- "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/users') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users";

    let payload = (
        json!({
            "id": "",
            "display_name": "",
            "password": "",
            "description": "",
            "is_system": ""
        })
    );

    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}}/terminal/v1/users \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

echo '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]' |  \
  http POST {{baseUrl}}/terminal/v1/users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "display_name": "",\n    "password": "",\n    "description": "",\n    "is_system": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

DELETE Delete One User

{{baseUrl}}/terminal/v1/users/:id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/terminal/v1/users/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/users/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/terminal/v1/users/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/terminal/v1/users/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/terminal/v1/users/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/terminal/v1/users/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/users/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/terminal/v1/users/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/terminal/v1/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/users/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/terminal/v1/users/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/terminal/v1/users/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/terminal/v1/users/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/terminal/v1/users/:id

http DELETE {{baseUrl}}/terminal/v1/users/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get One User

{{baseUrl}}/terminal/v1/users/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/users/:id")

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/users/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id"

	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/terminal/v1/users/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/users/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id"))
    .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}}/terminal/v1/users/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/users/:id")
  .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}}/terminal/v1/users/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id';
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}}/terminal/v1/users/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users/:id',
  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}}/terminal/v1/users/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/users/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id';
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}}/terminal/v1/users/:id"]
                                                       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}}/terminal/v1/users/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id",
  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}}/terminal/v1/users/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/users/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/users/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id";

    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}}/terminal/v1/users/:id

http GET {{baseUrl}}/terminal/v1/users/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "test01",
    "display_name": "test user 01",
    "password": "password",
    "description": "description",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get User Menus

{{baseUrl}}/terminal/v1/users/:id/menus

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id/menus");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/users/:id/menus")

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id/menus"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id/menus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/users/:id/menus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id/menus"

	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/terminal/v1/users/:id/menus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/users/:id/menus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id/menus"))
    .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}}/terminal/v1/users/:id/menus")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/users/:id/menus")
  .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}}/terminal/v1/users/:id/menus');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users/:id/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id/menus';
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}}/terminal/v1/users/:id/menus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/menus")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users/:id/menus',
  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}}/terminal/v1/users/:id/menus'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/users/:id/menus');

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}}/terminal/v1/users/:id/menus'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id/menus';
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}}/terminal/v1/users/:id/menus"]
                                                       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}}/terminal/v1/users/:id/menus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id/menus",
  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}}/terminal/v1/users/:id/menus');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id/menus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/users/:id/menus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users/:id/menus' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id/menus' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/users/:id/menus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id/menus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id/menus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users/:id/menus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/users/:id/menus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id/menus";

    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}}/terminal/v1/users/:id/menus

http GET {{baseUrl}}/terminal/v1/users/:id/menus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id/menus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id/menus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET Get User Roles

{{baseUrl}}/terminal/v1/users/:id/roles

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id/roles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/users/:id/roles")

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id/roles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id/roles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/users/:id/roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id/roles"

	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/terminal/v1/users/:id/roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/users/:id/roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id/roles"))
    .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}}/terminal/v1/users/:id/roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/users/:id/roles")
  .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}}/terminal/v1/users/:id/roles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users/:id/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id/roles';
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}}/terminal/v1/users/:id/roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/roles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users/:id/roles',
  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}}/terminal/v1/users/:id/roles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/users/:id/roles');

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}}/terminal/v1/users/:id/roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id/roles';
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}}/terminal/v1/users/:id/roles"]
                                                       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}}/terminal/v1/users/:id/roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id/roles",
  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}}/terminal/v1/users/:id/roles');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id/roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/users/:id/roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users/:id/roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id/roles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/users/:id/roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id/roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id/roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users/:id/roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/users/:id/roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id/roles";

    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}}/terminal/v1/users/:id/roles

http GET {{baseUrl}}/terminal/v1/users/:id/roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id/roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

GET List Users

{{baseUrl}}/terminal/v1/users

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/terminal/v1/users")

require "http/client"

url = "{{baseUrl}}/terminal/v1/users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/terminal/v1/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/terminal/v1/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/terminal/v1/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/terminal/v1/users")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/terminal/v1/users');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/terminal/v1/users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/terminal/v1/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/terminal/v1/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/terminal/v1/users');

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/terminal/v1/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/terminal/v1/users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/terminal/v1/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/terminal/v1/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/terminal/v1/users

http GET {{baseUrl}}/terminal/v1/users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/terminal/v1/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Reset User Password

{{baseUrl}}/terminal/v1/users/:id/reset-password

QUERY PARAMS

BODY json

{
  "password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id/reset-password");

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  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/users/:id/reset-password" {:content-type :json
                                                                                 :form-params {:password ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id/reset-password"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"password\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id/reset-password"),
    Content = new StringContent("{\n  \"password\": \"\"\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}}/terminal/v1/users/:id/reset-password");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id/reset-password"

	payload := strings.NewReader("{\n  \"password\": \"\"\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/terminal/v1/users/:id/reset-password HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/users/:id/reset-password")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id/reset-password"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"password\": \"\"\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  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/reset-password")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/users/:id/reset-password")
  .header("content-type", "application/json")
  .body("{\n  \"password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/users/:id/reset-password');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users/:id/reset-password',
  headers: {'content-type': 'application/json'},
  data: {password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id/reset-password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users/:id/reset-password',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/reset-password")
  .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/terminal/v1/users/:id/reset-password',
  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({password: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users/:id/reset-password',
  headers: {'content-type': 'application/json'},
  body: {password: ''},
  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}}/terminal/v1/users/:id/reset-password');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  password: ''
});

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}}/terminal/v1/users/:id/reset-password',
  headers: {'content-type': 'application/json'},
  data: {password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id/reset-password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":""}'
};

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 = @{ @"password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users/:id/reset-password"]
                                                       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}}/terminal/v1/users/:id/reset-password" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"password\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id/reset-password",
  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([
    'password' => ''
  ]),
  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}}/terminal/v1/users/:id/reset-password', [
  'body' => '{
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id/reset-password');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/users/:id/reset-password');
$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}}/terminal/v1/users/:id/reset-password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id/reset-password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"password\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/users/:id/reset-password", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id/reset-password"

payload = { "password": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id/reset-password"

payload <- "{\n  \"password\": \"\"\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}}/terminal/v1/users/:id/reset-password")

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  \"password\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/users/:id/reset-password') do |req|
  req.body = "{\n  \"password\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id/reset-password";

    let payload = json!({"password": ""});

    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}}/terminal/v1/users/:id/reset-password \
  --header 'content-type: application/json' \
  --data '{
  "password": ""
}'

echo '{
  "password": ""
}' |  \
  http POST {{baseUrl}}/terminal/v1/users/:id/reset-password \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id/reset-password

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["password": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id/reset-password")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "test01",
    "display_name": "test user 01",
    "password": "password",
    "description": "description",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Set User Roles

{{baseUrl}}/terminal/v1/users/:id/roles

BODY json

[
  {}
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id/roles");

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  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/users/:id/roles" {:content-type :json
                                                                        :form-params [{}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id/roles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {}\n]"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id/roles"),
    Content = new StringContent("[\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}}/terminal/v1/users/:id/roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id/roles"

	payload := strings.NewReader("[\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/terminal/v1/users/:id/roles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/users/:id/roles")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id/roles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\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  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/roles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/users/:id/roles")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/users/:id/roles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users/:id/roles',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id/roles';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users/:id/roles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id/roles")
  .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/terminal/v1/users/:id/roles',
  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([{}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/users/:id/roles',
  headers: {'content-type': 'application/json'},
  body: [{}],
  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}}/terminal/v1/users/:id/roles');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {}
]);

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}}/terminal/v1/users/:id/roles',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id/roles';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users/:id/roles"]
                                                       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}}/terminal/v1/users/:id/roles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id/roles",
  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([
    [
        
    ]
  ]),
  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}}/terminal/v1/users/:id/roles', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id/roles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/users/:id/roles');
$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}}/terminal/v1/users/:id/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {}\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/users/:id/roles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id/roles"

payload = [{}]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id/roles"

payload <- "[\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}}/terminal/v1/users/:id/roles")

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  {}\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/users/:id/roles') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id/roles";

    let payload = (json!({}));

    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}}/terminal/v1/users/:id/roles \
  --header 'content-type: application/json' \
  --data '[
  {}
]'

echo '[
  {}
]' |  \
  http POST {{baseUrl}}/terminal/v1/users/:id/roles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id/roles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id/roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

POST Update My Password

{{baseUrl}}/terminal/v1/user-password

BODY json

{
  "newPassword": "",
  "oldPassword": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/user-password");

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  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/terminal/v1/user-password" {:content-type :json
                                                                      :form-params {:newPassword ""
                                                                                    :oldPassword ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/user-password"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/user-password"),
    Content = new StringContent("{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\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}}/terminal/v1/user-password");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/user-password"

	payload := strings.NewReader("{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\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/terminal/v1/user-password HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "newPassword": "",
  "oldPassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/terminal/v1/user-password")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/user-password"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\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  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/user-password")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/terminal/v1/user-password")
  .header("content-type", "application/json")
  .body("{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  newPassword: '',
  oldPassword: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/terminal/v1/user-password');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/user-password',
  headers: {'content-type': 'application/json'},
  data: {newPassword: '', oldPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/user-password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPassword":"","oldPassword":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/user-password',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "newPassword": "",\n  "oldPassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/user-password")
  .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/terminal/v1/user-password',
  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({newPassword: '', oldPassword: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/terminal/v1/user-password',
  headers: {'content-type': 'application/json'},
  body: {newPassword: '', oldPassword: ''},
  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}}/terminal/v1/user-password');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  newPassword: '',
  oldPassword: ''
});

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}}/terminal/v1/user-password',
  headers: {'content-type': 'application/json'},
  data: {newPassword: '', oldPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/user-password';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPassword":"","oldPassword":""}'
};

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 = @{ @"newPassword": @"",
                              @"oldPassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/user-password"]
                                                       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}}/terminal/v1/user-password" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/user-password",
  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([
    'newPassword' => '',
    'oldPassword' => ''
  ]),
  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}}/terminal/v1/user-password', [
  'body' => '{
  "newPassword": "",
  "oldPassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/user-password');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'newPassword' => '',
  'oldPassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'newPassword' => '',
  'oldPassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/user-password');
$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}}/terminal/v1/user-password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPassword": "",
  "oldPassword": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/user-password' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPassword": "",
  "oldPassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/terminal/v1/user-password", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/user-password"

payload = {
    "newPassword": "",
    "oldPassword": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/user-password"

payload <- "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\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}}/terminal/v1/user-password")

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  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/terminal/v1/user-password') do |req|
  req.body = "{\n  \"newPassword\": \"\",\n  \"oldPassword\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/user-password";

    let payload = json!({
        "newPassword": "",
        "oldPassword": ""
    });

    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}}/terminal/v1/user-password \
  --header 'content-type: application/json' \
  --data '{
  "newPassword": "",
  "oldPassword": ""
}'

echo '{
  "newPassword": "",
  "oldPassword": ""
}' |  \
  http POST {{baseUrl}}/terminal/v1/user-password \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "newPassword": "",\n  "oldPassword": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/user-password

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "newPassword": "",
  "oldPassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/user-password")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "test01",
    "display_name": "test user 01",
    "password": "password",
    "description": "description",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update One User

{{baseUrl}}/terminal/v1/users/:id

BODY json

{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users/:id");

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  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/users/:id" {:content-type :json
                                                                   :form-params {:id ""
                                                                                 :display_name ""
                                                                                 :password ""
                                                                                 :description ""
                                                                                 :is_system ""}})

require "http/client"

url = "{{baseUrl}}/terminal/v1/users/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users/:id"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\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}}/terminal/v1/users/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users/:id"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/users/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 94

{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/users/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\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  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/users/:id")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  display_name: '',
  password: '',
  description: '',
  is_system: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/users/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', display_name: '', password: '', description: '', is_system: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","display_name":"","password":"","description":"","is_system":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "display_name": "",\n  "password": "",\n  "description": "",\n  "is_system": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users/:id',
  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({id: '', display_name: '', password: '', description: '', is_system: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users/:id',
  headers: {'content-type': 'application/json'},
  body: {id: '', display_name: '', password: '', description: '', is_system: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/users/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: '',
  display_name: '',
  password: '',
  description: '',
  is_system: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users/:id',
  headers: {'content-type': 'application/json'},
  data: {id: '', display_name: '', password: '', description: '', is_system: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","display_name":"","password":"","description":"","is_system":""}'
};

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 = @{ @"id": @"",
                              @"display_name": @"",
                              @"password": @"",
                              @"description": @"",
                              @"is_system": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/users/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => '',
    'display_name' => '',
    'password' => '',
    'description' => '',
    'is_system' => ''
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/users/:id', [
  'body' => '{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'display_name' => '',
  'password' => '',
  'description' => '',
  'is_system' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => '',
  'display_name' => '',
  'password' => '',
  'description' => '',
  'is_system' => ''
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/users/:id');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/users/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/users/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users/:id"

payload = {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users/:id"

payload <- "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/users/:id') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"display_name\": \"\",\n  \"password\": \"\",\n  \"description\": \"\",\n  \"is_system\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users/:id";

    let payload = json!({
        "id": "",
        "display_name": "",
        "password": "",
        "description": "",
        "is_system": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/users/:id \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}'

echo '{
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
}' |  \
  http PATCH {{baseUrl}}/terminal/v1/users/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "display_name": "",\n  "password": "",\n  "description": "",\n  "is_system": ""\n}' \
  --output-document \
  - {{baseUrl}}/terminal/v1/users/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "display_name": "",
  "password": "",
  "description": "",
  "is_system": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "id": "test01",
    "display_name": "test user 01",
    "password": "password",
    "description": "description",
    "is_system": "yes"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

PATCH Update Users

{{baseUrl}}/terminal/v1/users

BODY json

[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/terminal/v1/users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/terminal/v1/users" {:content-type :json
                                                               :form-params [{:id ""
                                                                              :display_name ""
                                                                              :password ""
                                                                              :description ""
                                                                              :is_system ""}]})

require "http/client"

url = "{{baseUrl}}/terminal/v1/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/terminal/v1/users"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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}}/terminal/v1/users");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/terminal/v1/users"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/terminal/v1/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/terminal/v1/users")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/terminal/v1/users"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\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  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/terminal/v1/users")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    display_name: '',
    password: '',
    description: '',
    is_system: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/terminal/v1/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', display_name: '', password: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/terminal/v1/users';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","display_name":"","password":"","description":"","is_system":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/terminal/v1/users',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "display_name": "",\n    "password": "",\n    "description": "",\n    "is_system": ""\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  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/terminal/v1/users")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/terminal/v1/users',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([{id: '', display_name: '', password: '', description: '', is_system: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  body: [{id: '', display_name: '', password: '', description: '', is_system: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/terminal/v1/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    display_name: '',
    password: '',
    description: '',
    is_system: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/terminal/v1/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', display_name: '', password: '', description: '', is_system: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/terminal/v1/users';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","display_name":"","password":"","description":"","is_system":""}]'
};

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 = @[ @{ @"id": @"", @"display_name": @"", @"password": @"", @"description": @"", @"is_system": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/terminal/v1/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/terminal/v1/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/terminal/v1/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'display_name' => '',
        'password' => '',
        'description' => '',
        'is_system' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/terminal/v1/users', [
  'body' => '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/terminal/v1/users');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'display_name' => '',
    'password' => '',
    'description' => '',
    'is_system' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'display_name' => '',
    'password' => '',
    'description' => '',
    'is_system' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/terminal/v1/users');
$request->setRequestMethod('PATCH');
$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}}/terminal/v1/users' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/terminal/v1/users' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/terminal/v1/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/terminal/v1/users"

payload = [
    {
        "id": "",
        "display_name": "",
        "password": "",
        "description": "",
        "is_system": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/terminal/v1/users"

payload <- "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/terminal/v1/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/terminal/v1/users') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"display_name\": \"\",\n    \"password\": \"\",\n    \"description\": \"\",\n    \"is_system\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/terminal/v1/users";

    let payload = (
        json!({
            "id": "",
            "display_name": "",
            "password": "",
            "description": "",
            "is_system": ""
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/terminal/v1/users \
  --header 'content-type: application/json' \
  --data '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]'

echo '[
  {
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  }
]' |  \
  http PATCH {{baseUrl}}/terminal/v1/users \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "display_name": "",\n    "password": "",\n    "description": "",\n    "is_system": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/terminal/v1/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "display_name": "",
    "password": "",
    "description": "",
    "is_system": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/terminal/v1/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "code": 200,
  "status": "OK",
  "message": "successed",
  "data": {
    "count": 1
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "title": "Unauthorized",
  "code": 401,
  "status": "ERROR",
  "data": null,
  "message": "you are unauthenticated, login needed"
}

WeCube Terminal API