Nest-Admin

GET 参数设置-列表

{{baseUrl}}/system/config/list

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/list?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/config/list" {:query-params {:pageNum ""
                                                                             :pageSize ""}
                                                              :content-type :json
                                                              :form-params {:pageNum ""
                                                                            :pageSize ""
                                                                            :params ""
                                                                            :orderByColumn ""
                                                                            :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/config/list?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/config/list?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/config/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/list?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")

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

}

GET /baseUrl/system/config/list?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/config/list?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config/list?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/config/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/config/list?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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

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

xhr.open('GET', '{{baseUrl}}/system/config/list?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/config/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

const url = '{{baseUrl}}/system/config/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/config/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/config/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/config/list?pageNum=&pageSize=',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/config/list',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/config/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/config/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

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

const url = '{{baseUrl}}/system/config/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/config/list?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/config/list?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

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

 "{{baseUrl}}/system/config/list?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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('GET', '{{baseUrl}}/system/config/list?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

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

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

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/config/list');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/config/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

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

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

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

conn.request("GET", "/baseUrl/system/config/list?pageNum=&pageSize=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/config/list"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config/list?pageNum=&pageSize=")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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.get('/baseUrl/system/config/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/config/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

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

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/config/list?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http GET '{{baseUrl}}/system/config/list?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/config/list?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST 参数设置-创建

{{baseUrl}}/system/config

BODY json

{
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/config" {:content-type :json
                                                          :form-params {:remark ""
                                                                        :status ""}})

require "http/client"

url = "{{baseUrl}}/system/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/config"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/system/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/config")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  status: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/system/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

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

const url = '{{baseUrl}}/system/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/config',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  body: {remark: '', status: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/config');

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

req.type('json');
req.send({
  remark: '',
  status: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

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

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

const url = '{{baseUrl}}/system/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"remark": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/system/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/system/config', [
  'body' => '{
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/config');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/config');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("POST", "/baseUrl/system/config", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/config"

payload = {
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config"

payload <- "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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/system/config') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "remark": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/config \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "status": ""
}'

echo '{
  "remark": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/system/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "status": ""
] as [String : Any]

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

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

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

dataTask.resume()

DELETE 参数设置-删除

{{baseUrl}}/system/config/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/system/config/:id")

require "http/client"

url = "{{baseUrl}}/system/config/: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}}/system/config/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/: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/system/config/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/config/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config/: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}}/system/config/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/system/config/: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}}/system/config/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/config/:id'};

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

const url = '{{baseUrl}}/system/config/: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}}/system/config/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/config/: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/system/config/: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}}/system/config/: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}}/system/config/: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}}/system/config/:id'};

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

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

const url = '{{baseUrl}}/system/config/: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}}/system/config/: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}}/system/config/:id" in

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

 "{{baseUrl}}/system/config/: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}}/system/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/system/config/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/system/config/:id")

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

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

import requests

url = "{{baseUrl}}/system/config/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config/: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/system/config/: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}}/system/config/: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}}/system/config/:id

http DELETE {{baseUrl}}/system/config/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/: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()

DELETE 参数设置-刷新缓存

{{baseUrl}}/system/config/refreshCache

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/refreshCache");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/system/config/refreshCache")

require "http/client"

url = "{{baseUrl}}/system/config/refreshCache"

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}}/system/config/refreshCache"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config/refreshCache");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/refreshCache"

	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/system/config/refreshCache HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/config/refreshCache")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config/refreshCache"))
    .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}}/system/config/refreshCache")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/system/config/refreshCache")
  .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}}/system/config/refreshCache');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/system/config/refreshCache'
};

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

const url = '{{baseUrl}}/system/config/refreshCache';
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}}/system/config/refreshCache',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/config/refreshCache")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/config/refreshCache',
  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}}/system/config/refreshCache'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/system/config/refreshCache');

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}}/system/config/refreshCache'
};

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

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

const url = '{{baseUrl}}/system/config/refreshCache';
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}}/system/config/refreshCache"]
                                                       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}}/system/config/refreshCache" in

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

 "{{baseUrl}}/system/config/refreshCache",
  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}}/system/config/refreshCache');

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/refreshCache');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/system/config/refreshCache');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config/refreshCache' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/refreshCache' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/system/config/refreshCache")

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

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

import requests

url = "{{baseUrl}}/system/config/refreshCache"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/refreshCache"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config/refreshCache")

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/system/config/refreshCache') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/config/refreshCache";

    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}}/system/config/refreshCache

http DELETE {{baseUrl}}/system/config/refreshCache

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/config/refreshCache

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/refreshCache")! 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()

PUT 参数设置-更新

{{baseUrl}}/system/config

BODY json

{
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/system/config" {:content-type :json
                                                         :form-params {:remark ""
                                                                       :status ""}})

require "http/client"

url = "{{baseUrl}}/system/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/config"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/system/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/system/config")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  status: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/system/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

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

const url = '{{baseUrl}}/system/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/config',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  body: {remark: '', status: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/config');

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

req.type('json');
req.send({
  remark: '',
  status: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/config',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

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

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

const url = '{{baseUrl}}/system/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"remark": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/system/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/system/config', [
  'body' => '{
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/config');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/config');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/system/config", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/config"

payload = {
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config"

payload <- "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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.put('/baseUrl/system/config') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/config";

    let payload = json!({
        "remark": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/config \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "status": ""
}'

echo '{
  "remark": "",
  "status": ""
}' |  \
  http PUT {{baseUrl}}/system/config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET 参数设置-详情(configKey)【走缓存】

{{baseUrl}}/system/config/configKey/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/configKey/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/config/configKey/:id")

require "http/client"

url = "{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config/configKey/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/configKey/: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/system/config/configKey/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/config/configKey/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/config/configKey/:id'};

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

const url = '{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/config/configKey/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/: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}}/system/config/configKey/:id" in

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

 "{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/configKey/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/config/configKey/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config/configKey/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/configKey/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/config/configKey/:id")

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

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

import requests

url = "{{baseUrl}}/system/config/configKey/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/configKey/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config/configKey/: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/system/config/configKey/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/config/configKey/: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}}/system/config/configKey/:id

http GET {{baseUrl}}/system/config/configKey/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/config/configKey/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/configKey/: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()

GET 参数设置-详情(id)

{{baseUrl}}/system/config/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/config/:id")

require "http/client"

url = "{{baseUrl}}/system/config/: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}}/system/config/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/config/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/: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/system/config/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/config/:id'};

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

const url = '{{baseUrl}}/system/config/: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}}/system/config/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/config/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/system/config/: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}}/system/config/: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}}/system/config/:id" in

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

 "{{baseUrl}}/system/config/: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}}/system/config/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/config/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/config/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/config/:id")

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

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

import requests

url = "{{baseUrl}}/system/config/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/config/: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/system/config/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/config/: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}}/system/config/:id

http GET {{baseUrl}}/system/config/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/config/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/: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()

POST 导出参数管理为xlsx文件

{{baseUrl}}/system/config/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/config/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/config/export" {:content-type :json
                                                                 :form-params {:pageNum ""
                                                                               :pageSize ""
                                                                               :params ""
                                                                               :orderByColumn ""
                                                                               :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/config/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/config/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/config/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/config/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/config/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/config/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/config/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/config/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/config/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/system/config/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/config/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

const url = '{{baseUrl}}/system/config/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/config/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/config/export")
  .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/system/config/export',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/config/export',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  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}}/system/config/export');

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

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/config/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

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

const url = '{{baseUrl}}/system/config/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/config/export"]
                                                       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}}/system/config/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

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

 "{{baseUrl}}/system/config/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/system/config/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/config/export');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

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

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

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/config/export');
$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}}/system/config/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/config/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

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

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

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

conn.request("POST", "/baseUrl/system/config/export", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/config/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/config/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/config/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/config/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/config/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/system/config/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/system/config/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/config/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/config/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET 全部字典类型-下拉数据

{{baseUrl}}/system/dict/type/optionselect

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/optionselect");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/type/optionselect")

require "http/client"

url = "{{baseUrl}}/system/dict/type/optionselect"

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}}/system/dict/type/optionselect"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type/optionselect");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/optionselect"

	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/system/dict/type/optionselect HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/type/optionselect")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type/optionselect"))
    .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}}/system/dict/type/optionselect")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/type/optionselect")
  .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}}/system/dict/type/optionselect');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/dict/type/optionselect'
};

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

const url = '{{baseUrl}}/system/dict/type/optionselect';
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}}/system/dict/type/optionselect',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/optionselect")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/dict/type/optionselect');

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}}/system/dict/type/optionselect'
};

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

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

const url = '{{baseUrl}}/system/dict/type/optionselect';
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}}/system/dict/type/optionselect"]
                                                       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}}/system/dict/type/optionselect" in

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

 "{{baseUrl}}/system/dict/type/optionselect",
  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}}/system/dict/type/optionselect');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/optionselect');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/dict/type/optionselect');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type/optionselect' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/optionselect' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/type/optionselect")

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

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

import requests

url = "{{baseUrl}}/system/dict/type/optionselect"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/optionselect"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type/optionselect")

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/system/dict/type/optionselect') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type/optionselect";

    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}}/system/dict/type/optionselect

http GET {{baseUrl}}/system/dict/type/optionselect

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dict/type/optionselect

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/optionselect")! 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()

PUT 字典数据-修改

{{baseUrl}}/system/dict/data

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/system/dict/data" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/system/dict/data"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/dict/data"),
    Content = new StringContent("{}")
    {
        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}}/system/dict/data");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/system/dict/data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/dict/data")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/data")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/system/dict/data")
  .header("content-type", "application/json")
  .body("{}")
  .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('PUT', '{{baseUrl}}/system/dict/data');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dict/data',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/system/dict/data';
const options = {method: 'PUT', 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}}/system/dict/data',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/data',
  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: 'PUT',
  url: '{{baseUrl}}/system/dict/data',
  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('PUT', '{{baseUrl}}/system/dict/data');

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: 'PUT',
  url: '{{baseUrl}}/system/dict/data',
  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}}/system/dict/data';
const options = {method: 'PUT', 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}}/system/dict/data"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/dict/data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/system/dict/data",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/system/dict/data', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data');
$request->setMethod(HTTP_METH_PUT);

$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}}/system/dict/data');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/data' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("PUT", "/baseUrl/system/dict/data", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/data"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/data")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

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

response = conn.put('/baseUrl/system/dict/data') do |req|
  req.body = "{}"
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}}/system/dict/data";

    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.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/dict/data \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http PUT {{baseUrl}}/system/dict/data \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/system/dict/data

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}}/system/dict/data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET 字典数据-列表

{{baseUrl}}/system/dict/data/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/data/list" {:query-params {:pageNum ""
                                                                                :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize="

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}}/system/dict/data/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize="

	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/system/dict/data/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data/list?pageNum=&pageSize="))
    .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}}/system/dict/data/list?pageNum=&pageSize=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=")
  .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}}/system/dict/data/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/dict/data/list',
  params: {pageNum: '', pageSize: ''}
};

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

const url = '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=';
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}}/system/dict/data/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/data/list?pageNum=&pageSize=',
  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}}/system/dict/data/list',
  qs: {pageNum: '', pageSize: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/dict/data/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/system/dict/data/list',
  params: {pageNum: '', pageSize: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=';
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}}/system/dict/data/list?pageNum=&pageSize="]
                                                       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}}/system/dict/data/list?pageNum=&pageSize=" in

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

 "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=",
  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}}/system/dict/data/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/system/dict/data/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/data/list?pageNum=&pageSize=")

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

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

import requests

url = "{{baseUrl}}/system/dict/data/list"

querystring = {"pageNum":"","pageSize":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=")

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/system/dict/data/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/data/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/system/dict/data/list?pageNum=&pageSize='

http GET '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/system/dict/data/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/data/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

POST 字典数据-创建

{{baseUrl}}/system/dict/data

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/dict/data" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/system/dict/data"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/system/dict/data"),
    Content = new StringContent("{}")
    {
        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}}/system/dict/data");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data"

	payload := strings.NewReader("{}")

	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/system/dict/data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/dict/data")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/dict/data")
  .header("content-type", "application/json")
  .body("{}")
  .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}}/system/dict/data');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/data',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/system/dict/data';
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}}/system/dict/data',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data")
  .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/system/dict/data',
  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}}/system/dict/data',
  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}}/system/dict/data');

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}}/system/dict/data',
  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}}/system/dict/data';
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}}/system/dict/data"]
                                                       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}}/system/dict/data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/system/dict/data",
  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}}/system/dict/data', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data');
$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}}/system/dict/data');
$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}}/system/dict/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/system/dict/data", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/data"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data"

payload <- "{}"

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}}/system/dict/data")

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 = "{}"

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/system/dict/data') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/data";

    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}}/system/dict/data \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/system/dict/data \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/system/dict/data

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}}/system/dict/data")! 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()

DELETE 字典数据-删除

{{baseUrl}}/system/dict/data/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/system/dict/data/:id")

require "http/client"

url = "{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/data/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data/: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/system/dict/data/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/dict/data/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/dict/data/:id'};

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

const url = '{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data/: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/system/dict/data/: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}}/system/dict/data/: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}}/system/dict/data/: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}}/system/dict/data/:id'};

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

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

const url = '{{baseUrl}}/system/dict/data/: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}}/system/dict/data/: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}}/system/dict/data/:id" in

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

 "{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/system/dict/data/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/data/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/system/dict/data/:id")

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

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

import requests

url = "{{baseUrl}}/system/dict/data/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/data/: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/system/dict/data/: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}}/system/dict/data/: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}}/system/dict/data/:id

http DELETE {{baseUrl}}/system/dict/data/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/dict/data/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/data/: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()

DELETE 字典数据-刷新缓存

{{baseUrl}}/system/dict/type/refreshCache

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/refreshCache");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/system/dict/type/refreshCache")

require "http/client"

url = "{{baseUrl}}/system/dict/type/refreshCache"

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}}/system/dict/type/refreshCache"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type/refreshCache");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/refreshCache"

	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/system/dict/type/refreshCache HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/dict/type/refreshCache")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type/refreshCache"))
    .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}}/system/dict/type/refreshCache")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/system/dict/type/refreshCache")
  .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}}/system/dict/type/refreshCache');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/system/dict/type/refreshCache'
};

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

const url = '{{baseUrl}}/system/dict/type/refreshCache';
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}}/system/dict/type/refreshCache',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/refreshCache")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/type/refreshCache',
  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}}/system/dict/type/refreshCache'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/system/dict/type/refreshCache');

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}}/system/dict/type/refreshCache'
};

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

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

const url = '{{baseUrl}}/system/dict/type/refreshCache';
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}}/system/dict/type/refreshCache"]
                                                       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}}/system/dict/type/refreshCache" in

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

 "{{baseUrl}}/system/dict/type/refreshCache",
  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}}/system/dict/type/refreshCache');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/refreshCache');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/system/dict/type/refreshCache');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type/refreshCache' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/refreshCache' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/system/dict/type/refreshCache")

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

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

import requests

url = "{{baseUrl}}/system/dict/type/refreshCache"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/refreshCache"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type/refreshCache")

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/system/dict/type/refreshCache') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type/refreshCache";

    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}}/system/dict/type/refreshCache

http DELETE {{baseUrl}}/system/dict/type/refreshCache

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/dict/type/refreshCache

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/refreshCache")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

GET 字典数据-类型-详情【走缓存】

{{baseUrl}}/system/dict/data/type/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data/type/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/data/type/:id")

require "http/client"

url = "{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/data/type/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data/type/: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/system/dict/data/type/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/data/type/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dict/data/type/:id'};

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

const url = '{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data/type/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/data/type/: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}}/system/dict/data/type/: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}}/system/dict/data/type/: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}}/system/dict/data/type/:id'};

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

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

const url = '{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/: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}}/system/dict/data/type/:id" in

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

 "{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data/type/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/dict/data/type/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/data/type/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data/type/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/data/type/:id")

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

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

import requests

url = "{{baseUrl}}/system/dict/data/type/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data/type/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/data/type/: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/system/dict/data/type/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/data/type/: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}}/system/dict/data/type/:id

http GET {{baseUrl}}/system/dict/data/type/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dict/data/type/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/data/type/: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()

GET 字典数据-详情

{{baseUrl}}/system/dict/data/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/data/:id")

require "http/client"

url = "{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/data/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data/: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/system/dict/data/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/data/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dict/data/:id'};

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

const url = '{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/system/dict/data/: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}}/system/dict/data/: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}}/system/dict/data/:id" in

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

 "{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/dict/data/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/data/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/data/:id")

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

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

import requests

url = "{{baseUrl}}/system/dict/data/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/data/: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/system/dict/data/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/data/: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}}/system/dict/data/:id

http GET {{baseUrl}}/system/dict/data/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dict/data/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/data/: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()

PUT 字典类型-修改

{{baseUrl}}/system/dict/type

BODY json

{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type");

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  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/system/dict/type" {:content-type :json
                                                            :form-params {:dictName ""
                                                                          :dictType ""
                                                                          :remark ""
                                                                          :status ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/type"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/dict/type"),
    Content = new StringContent("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type"

	payload := strings.NewReader("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/system/dict/type HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/dict/type")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/type")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/system/dict/type")
  .header("content-type", "application/json")
  .body("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  dictName: '',
  dictType: '',
  remark: '',
  status: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/system/dict/type');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  data: {dictName: '', dictType: '', remark: '', status: ''}
};

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

const url = '{{baseUrl}}/system/dict/type';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"dictName":"","dictType":"","remark":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dict/type',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dictName": "",\n  "dictType": "",\n  "remark": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/type',
  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({dictName: '', dictType: '', remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  body: {dictName: '', dictType: '', remark: '', status: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/dict/type');

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

req.type('json');
req.send({
  dictName: '',
  dictType: '',
  remark: '',
  status: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  data: {dictName: '', dictType: '', remark: '', status: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/type';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"dictName":"","dictType":"","remark":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dictName": @"",
                              @"dictType": @"",
                              @"remark": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dict/type"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/dict/type" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/system/dict/type",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'dictName' => '',
    'dictType' => '',
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/system/dict/type', [
  'body' => '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'dictName' => '',
  'dictType' => '',
  'remark' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'dictName' => '',
  'dictType' => '',
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dict/type');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/system/dict/type", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/type"

payload = {
    "dictName": "",
    "dictType": "",
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type"

payload <- "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\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.put('/baseUrl/system/dict/type') do |req|
  req.body = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/dict/type";

    let payload = json!({
        "dictName": "",
        "dictType": "",
        "remark": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/dict/type \
  --header 'content-type: application/json' \
  --data '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

echo '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}' |  \
  http PUT {{baseUrl}}/system/dict/type \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "dictName": "",\n  "dictType": "",\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dict/type

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET 字典类型-列表

{{baseUrl}}/system/dict/type/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/type/list" {:query-params {:pageNum ""
                                                                                :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize="

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}}/system/dict/type/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize="

	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/system/dict/type/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type/list?pageNum=&pageSize="))
    .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}}/system/dict/type/list?pageNum=&pageSize=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=")
  .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}}/system/dict/type/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/dict/type/list',
  params: {pageNum: '', pageSize: ''}
};

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

const url = '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=';
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}}/system/dict/type/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dict/type/list?pageNum=&pageSize=',
  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}}/system/dict/type/list',
  qs: {pageNum: '', pageSize: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/dict/type/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/system/dict/type/list',
  params: {pageNum: '', pageSize: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=';
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}}/system/dict/type/list?pageNum=&pageSize="]
                                                       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}}/system/dict/type/list?pageNum=&pageSize=" in

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

 "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=",
  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}}/system/dict/type/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/system/dict/type/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/type/list?pageNum=&pageSize=")

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

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

import requests

url = "{{baseUrl}}/system/dict/type/list"

querystring = {"pageNum":"","pageSize":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=")

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/system/dict/type/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/system/dict/type/list?pageNum=&pageSize='

http GET '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/system/dict/type/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

POST 字典类型-创建

{{baseUrl}}/system/dict/type

BODY json

{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type");

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  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/dict/type" {:content-type :json
                                                             :form-params {:dictName ""
                                                                           :dictType ""
                                                                           :remark ""
                                                                           :status ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/type"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/dict/type"),
    Content = new StringContent("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type"

	payload := strings.NewReader("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/system/dict/type HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/dict/type")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/type")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/dict/type")
  .header("content-type", "application/json")
  .body("{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  dictName: '',
  dictType: '',
  remark: '',
  status: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/system/dict/type');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  data: {dictName: '', dictType: '', remark: '', status: ''}
};

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

const url = '{{baseUrl}}/system/dict/type';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dictName":"","dictType":"","remark":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dict/type',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dictName": "",\n  "dictType": "",\n  "remark": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type")
  .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/system/dict/type',
  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({dictName: '', dictType: '', remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  body: {dictName: '', dictType: '', remark: '', status: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/dict/type');

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

req.type('json');
req.send({
  dictName: '',
  dictType: '',
  remark: '',
  status: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/type',
  headers: {'content-type': 'application/json'},
  data: {dictName: '', dictType: '', remark: '', status: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/type';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dictName":"","dictType":"","remark":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dictName": @"",
                              @"dictType": @"",
                              @"remark": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dict/type"]
                                                       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}}/system/dict/type" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/system/dict/type",
  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([
    'dictName' => '',
    'dictType' => '',
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/system/dict/type', [
  'body' => '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'dictName' => '',
  'dictType' => '',
  'remark' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'dictName' => '',
  'dictType' => '',
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dict/type');
$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}}/system/dict/type' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("POST", "/baseUrl/system/dict/type", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/type"

payload = {
    "dictName": "",
    "dictType": "",
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type"

payload <- "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type")

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  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\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/system/dict/type') do |req|
  req.body = "{\n  \"dictName\": \"\",\n  \"dictType\": \"\",\n  \"remark\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type";

    let payload = json!({
        "dictName": "",
        "dictType": "",
        "remark": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/dict/type \
  --header 'content-type: application/json' \
  --data '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}'

echo '{
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/system/dict/type \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "dictName": "",\n  "dictType": "",\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dict/type

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "dictName": "",
  "dictType": "",
  "remark": "",
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type")! 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()

DELETE 字典类型-删除

{{baseUrl}}/system/dict/type/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/system/dict/type/:id")

require "http/client"

url = "{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/: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/system/dict/type/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/dict/type/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/dict/type/:id'};

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

const url = '{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/: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/system/dict/type/: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}}/system/dict/type/: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}}/system/dict/type/: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}}/system/dict/type/:id'};

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

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

const url = '{{baseUrl}}/system/dict/type/: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}}/system/dict/type/: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}}/system/dict/type/:id" in

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

 "{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/system/dict/type/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/system/dict/type/:id")

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

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

import requests

url = "{{baseUrl}}/system/dict/type/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type/: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/system/dict/type/: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}}/system/dict/type/: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}}/system/dict/type/:id

http DELETE {{baseUrl}}/system/dict/type/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/dict/type/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/: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()

GET 字典类型-详情

{{baseUrl}}/system/dict/type/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/system/dict/type/:id")

require "http/client"

url = "{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dict/type/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/: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/system/dict/type/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dict/type/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dict/type/:id'};

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

const url = '{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/system/dict/type/: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}}/system/dict/type/: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}}/system/dict/type/:id" in

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

 "{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/system/dict/type/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dict/type/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/system/dict/type/:id")

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

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

import requests

url = "{{baseUrl}}/system/dict/type/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dict/type/: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/system/dict/type/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type/: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}}/system/dict/type/:id

http GET {{baseUrl}}/system/dict/type/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dict/type/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/: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()

POST 导出字典内容为xlsx文件

{{baseUrl}}/system/dict/data/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/data/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/dict/data/export" {:content-type :json
                                                                    :form-params {:pageNum ""
                                                                                  :pageSize ""
                                                                                  :params ""
                                                                                  :orderByColumn ""
                                                                                  :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/data/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/data/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/data/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/data/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/dict/data/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/dict/data/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/data/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/data/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/dict/data/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/system/dict/data/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/data/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

const url = '{{baseUrl}}/system/dict/data/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dict/data/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/data/export")
  .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/system/dict/data/export',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/data/export',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  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}}/system/dict/data/export');

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

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/dict/data/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/data/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dict/data/export"]
                                                       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}}/system/dict/data/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

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

 "{{baseUrl}}/system/dict/data/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/system/dict/data/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/data/export');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

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

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

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dict/data/export');
$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}}/system/dict/data/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/data/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

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

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

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

conn.request("POST", "/baseUrl/system/dict/data/export", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/data/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/data/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/data/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/dict/data/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/data/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/system/dict/data/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/system/dict/data/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dict/data/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/data/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST 导出字典组为xlsx文件

{{baseUrl}}/system/dict/type/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dict/type/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/system/dict/type/export" {:content-type :json
                                                                    :form-params {:pageNum ""
                                                                                  :pageSize ""
                                                                                  :params ""
                                                                                  :orderByColumn ""
                                                                                  :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/dict/type/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/type/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/type/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/system/dict/type/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/dict/type/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/dict/type/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dict/type/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dict/type/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/system/dict/type/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/system/dict/type/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/type/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

const url = '{{baseUrl}}/system/dict/type/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dict/type/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dict/type/export")
  .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/system/dict/type/export',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dict/type/export',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  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}}/system/dict/type/export');

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

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/dict/type/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

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

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

const url = '{{baseUrl}}/system/dict/type/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dict/type/export"]
                                                       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}}/system/dict/type/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

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

 "{{baseUrl}}/system/dict/type/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/system/dict/type/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dict/type/export');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

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

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

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dict/type/export');
$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}}/system/dict/type/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dict/type/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

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

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

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

conn.request("POST", "/baseUrl/system/dict/type/export", payload, headers)

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

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

import requests

url = "{{baseUrl}}/system/dict/type/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dict/type/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/dict/type/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/dict/type/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dict/type/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/system/dict/type/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/system/dict/type/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dict/type/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dict/type/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST 导出调度日志为xlsx文件

{{baseUrl}}/monitor/jobLog/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/jobLog/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/monitor/jobLog/export" {:content-type :json
                                                                  :form-params {:pageNum ""
                                                                                :pageSize ""
                                                                                :params ""
                                                                                :orderByColumn ""
                                                                                :isAsc ""
                                                                                :jobName ""
                                                                                :jobGroup ""
                                                                                :status ""}})

require "http/client"

url = "{{baseUrl}}/monitor/jobLog/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\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}}/monitor/jobLog/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/jobLog/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/jobLog/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/monitor/jobLog/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 142

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitor/jobLog/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/jobLog/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/jobLog/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/monitor/jobLog/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  jobName: '',
  jobGroup: '',
  status: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/monitor/jobLog/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/jobLog/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    jobName: '',
    jobGroup: '',
    status: ''
  }
};

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

const url = '{{baseUrl}}/monitor/jobLog/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","jobName":"","jobGroup":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/jobLog/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "jobName": "",\n  "jobGroup": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/jobLog/export")
  .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/monitor/jobLog/export',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  jobName: '',
  jobGroup: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/jobLog/export',
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    jobName: '',
    jobGroup: '',
    status: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/monitor/jobLog/export');

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

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  jobName: '',
  jobGroup: '',
  status: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/jobLog/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    jobName: '',
    jobGroup: '',
    status: ''
  }
};

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

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

const url = '{{baseUrl}}/monitor/jobLog/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","jobName":"","jobGroup":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"jobName": @"",
                              @"jobGroup": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/jobLog/export"]
                                                       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}}/monitor/jobLog/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/monitor/jobLog/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'jobName' => '',
    'jobGroup' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/monitor/jobLog/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/jobLog/export');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/jobLog/export');
$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}}/monitor/jobLog/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/jobLog/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("POST", "/baseUrl/monitor/jobLog/export", payload, headers)

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

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

import requests

url = "{{baseUrl}}/monitor/jobLog/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "jobName": "",
    "jobGroup": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/jobLog/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/jobLog/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\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/monitor/jobLog/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/jobLog/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "jobName": "",
        "jobGroup": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/monitor/jobLog/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/monitor/jobLog/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "jobName": "",\n  "jobGroup": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/jobLog/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "jobName": "",
  "jobGroup": "",
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/jobLog/export")! 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()

DELETE 清空定时任务日志

{{baseUrl}}/monitor/jobLog/clean

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/jobLog/clean");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/monitor/jobLog/clean")

require "http/client"

url = "{{baseUrl}}/monitor/jobLog/clean"

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}}/monitor/jobLog/clean"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/jobLog/clean");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/jobLog/clean"

	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/monitor/jobLog/clean HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/jobLog/clean")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/jobLog/clean"))
    .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}}/monitor/jobLog/clean")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/jobLog/clean")
  .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}}/monitor/jobLog/clean');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/jobLog/clean'};

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

const url = '{{baseUrl}}/monitor/jobLog/clean';
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}}/monitor/jobLog/clean',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/jobLog/clean")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/jobLog/clean',
  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}}/monitor/jobLog/clean'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/jobLog/clean');

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}}/monitor/jobLog/clean'};

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

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

const url = '{{baseUrl}}/monitor/jobLog/clean';
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}}/monitor/jobLog/clean"]
                                                       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}}/monitor/jobLog/clean" in

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

 "{{baseUrl}}/monitor/jobLog/clean",
  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}}/monitor/jobLog/clean');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/jobLog/clean');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/monitor/jobLog/clean');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/jobLog/clean' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/jobLog/clean' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/monitor/jobLog/clean")

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

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

import requests

url = "{{baseUrl}}/monitor/jobLog/clean"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/jobLog/clean"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/jobLog/clean")

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/monitor/jobLog/clean') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/jobLog/clean";

    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}}/monitor/jobLog/clean

http DELETE {{baseUrl}}/monitor/jobLog/clean

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/jobLog/clean

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/jobLog/clean")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

GET 获取定时任务日志列表

{{baseUrl}}/monitor/jobLog/list

QUERY PARAMS

pageNum

pageSize

jobName

jobGroup

status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/monitor/jobLog/list" {:query-params {:pageNum ""
                                                                              :pageSize ""
                                                                              :jobName ""
                                                                              :jobGroup ""
                                                                              :status ""}})

require "http/client"

url = "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status="

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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status="

	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/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status="))
    .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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")
  .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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/jobLog/list',
  params: {pageNum: '', pageSize: '', jobName: '', jobGroup: '', status: ''}
};

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

const url = '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=';
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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=',
  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}}/monitor/jobLog/list',
  qs: {pageNum: '', pageSize: '', jobName: '', jobGroup: '', status: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/jobLog/list');

req.query({
  pageNum: '',
  pageSize: '',
  jobName: '',
  jobGroup: '',
  status: ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/jobLog/list',
  params: {pageNum: '', pageSize: '', jobName: '', jobGroup: '', status: ''}
};

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

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

const url = '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=';
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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status="]
                                                       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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=" in

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

 "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=",
  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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/jobLog/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => '',
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/monitor/jobLog/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => '',
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")

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

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

import requests

url = "{{baseUrl}}/monitor/jobLog/list"

querystring = {"pageNum":"","pageSize":"","jobName":"","jobGroup":"","status":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/jobLog/list"

queryString <- list(
  pageNum = "",
  pageSize = "",
  jobName = "",
  jobGroup = "",
  status = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")

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/monitor/jobLog/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.params['jobName'] = ''
  req.params['jobGroup'] = ''
  req.params['status'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/jobLog/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
        ("jobName", ""),
        ("jobGroup", ""),
        ("status", ""),
    ];

    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}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status='

http GET '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/jobLog/list?pageNum=&pageSize=&jobName=&jobGroup=&status=")! 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()

PUT 修改任务状态

{{baseUrl}}/monitor/job/changeStatus

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/changeStatus");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/monitor/job/changeStatus")

require "http/client"

url = "{{baseUrl}}/monitor/job/changeStatus"

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

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

var client = new RestClient("{{baseUrl}}/monitor/job/changeStatus");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job/changeStatus"

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

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

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

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

}

PUT /baseUrl/monitor/job/changeStatus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/monitor/job/changeStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/changeStatus"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job/changeStatus")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/monitor/job/changeStatus")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/monitor/job/changeStatus');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/changeStatus'};

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

const url = '{{baseUrl}}/monitor/job/changeStatus';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job/changeStatus',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/changeStatus")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job/changeStatus',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/changeStatus'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/monitor/job/changeStatus');

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

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

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

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/changeStatus'};

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

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

const url = '{{baseUrl}}/monitor/job/changeStatus';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job/changeStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/monitor/job/changeStatus" in

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

 "{{baseUrl}}/monitor/job/changeStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/monitor/job/changeStatus');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/changeStatus');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/monitor/job/changeStatus');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job/changeStatus' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/changeStatus' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/monitor/job/changeStatus")

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

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

import requests

url = "{{baseUrl}}/monitor/job/changeStatus"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/changeStatus"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/changeStatus")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/monitor/job/changeStatus') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/changeStatus";

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/monitor/job/changeStatus

http PUT {{baseUrl}}/monitor/job/changeStatus

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/monitor/job/changeStatus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/changeStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

PUT 修改定时任务

{{baseUrl}}/monitor/job

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/monitor/job")

require "http/client"

url = "{{baseUrl}}/monitor/job"

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

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

var client = new RestClient("{{baseUrl}}/monitor/job");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job"

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

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

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

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

}

PUT /baseUrl/monitor/job HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/monitor/job")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/monitor/job")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/monitor/job');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job'};

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

const url = '{{baseUrl}}/monitor/job';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/monitor/job');

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

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

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

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job'};

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

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

const url = '{{baseUrl}}/monitor/job';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/monitor/job" in

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

 "{{baseUrl}}/monitor/job",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/monitor/job');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/monitor/job');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/monitor/job")

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

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

import requests

url = "{{baseUrl}}/monitor/job"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/monitor/job') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/monitor/job

http PUT {{baseUrl}}/monitor/job

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/monitor/job

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

dataTask.resume()

POST 创建定时任务

{{baseUrl}}/monitor/job

BODY json

{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job");

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  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/monitor/job" {:content-type :json
                                                        :form-params {:jobName ""
                                                                      :jobGroup ""
                                                                      :invokeTarget ""
                                                                      :cronExpression ""
                                                                      :misfirePolicy ""
                                                                      :concurrent ""
                                                                      :status ""
                                                                      :remark ""}})

require "http/client"

url = "{{baseUrl}}/monitor/job"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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}}/monitor/job"),
    Content = new StringContent("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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}}/monitor/job");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job"

	payload := strings.NewReader("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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/monitor/job HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 158

{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitor/job")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/monitor/job")
  .header("content-type", "application/json")
  .body("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobName: '',
  jobGroup: '',
  invokeTarget: '',
  cronExpression: '',
  misfirePolicy: '',
  concurrent: '',
  status: '',
  remark: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/monitor/job');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/job',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobGroup: '',
    invokeTarget: '',
    cronExpression: '',
    misfirePolicy: '',
    concurrent: '',
    status: '',
    remark: ''
  }
};

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

const url = '{{baseUrl}}/monitor/job';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobGroup":"","invokeTarget":"","cronExpression":"","misfirePolicy":"","concurrent":"","status":"","remark":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobName": "",\n  "jobGroup": "",\n  "invokeTarget": "",\n  "cronExpression": "",\n  "misfirePolicy": "",\n  "concurrent": "",\n  "status": "",\n  "remark": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job")
  .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/monitor/job',
  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({
  jobName: '',
  jobGroup: '',
  invokeTarget: '',
  cronExpression: '',
  misfirePolicy: '',
  concurrent: '',
  status: '',
  remark: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/job',
  headers: {'content-type': 'application/json'},
  body: {
    jobName: '',
    jobGroup: '',
    invokeTarget: '',
    cronExpression: '',
    misfirePolicy: '',
    concurrent: '',
    status: '',
    remark: ''
  },
  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}}/monitor/job');

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

req.type('json');
req.send({
  jobName: '',
  jobGroup: '',
  invokeTarget: '',
  cronExpression: '',
  misfirePolicy: '',
  concurrent: '',
  status: '',
  remark: ''
});

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}}/monitor/job',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobGroup: '',
    invokeTarget: '',
    cronExpression: '',
    misfirePolicy: '',
    concurrent: '',
    status: '',
    remark: ''
  }
};

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

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

const url = '{{baseUrl}}/monitor/job';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobGroup":"","invokeTarget":"","cronExpression":"","misfirePolicy":"","concurrent":"","status":"","remark":""}'
};

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 = @{ @"jobName": @"",
                              @"jobGroup": @"",
                              @"invokeTarget": @"",
                              @"cronExpression": @"",
                              @"misfirePolicy": @"",
                              @"concurrent": @"",
                              @"status": @"",
                              @"remark": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job"]
                                                       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}}/monitor/job" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}" in

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

 "{{baseUrl}}/monitor/job",
  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([
    'jobName' => '',
    'jobGroup' => '',
    'invokeTarget' => '',
    'cronExpression' => '',
    'misfirePolicy' => '',
    'concurrent' => '',
    'status' => '',
    'remark' => ''
  ]),
  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}}/monitor/job', [
  'body' => '{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobName' => '',
  'jobGroup' => '',
  'invokeTarget' => '',
  'cronExpression' => '',
  'misfirePolicy' => '',
  'concurrent' => '',
  'status' => '',
  'remark' => ''
]));

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

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

append(json_encode([
  'jobName' => '',
  'jobGroup' => '',
  'invokeTarget' => '',
  'cronExpression' => '',
  'misfirePolicy' => '',
  'concurrent' => '',
  'status' => '',
  'remark' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/job');
$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}}/monitor/job' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}'

import http.client

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

payload = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}"

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

conn.request("POST", "/baseUrl/monitor/job", payload, headers)

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

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

import requests

url = "{{baseUrl}}/monitor/job"

payload = {
    "jobName": "",
    "jobGroup": "",
    "invokeTarget": "",
    "cronExpression": "",
    "misfirePolicy": "",
    "concurrent": "",
    "status": "",
    "remark": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job"

payload <- "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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}}/monitor/job")

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  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\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/monitor/job') do |req|
  req.body = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"invokeTarget\": \"\",\n  \"cronExpression\": \"\",\n  \"misfirePolicy\": \"\",\n  \"concurrent\": \"\",\n  \"status\": \"\",\n  \"remark\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "jobName": "",
        "jobGroup": "",
        "invokeTarget": "",
        "cronExpression": "",
        "misfirePolicy": "",
        "concurrent": "",
        "status": "",
        "remark": ""
    });

    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}}/monitor/job \
  --header 'content-type: application/json' \
  --data '{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}'

echo '{
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
}' |  \
  http POST {{baseUrl}}/monitor/job \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobName": "",\n  "jobGroup": "",\n  "invokeTarget": "",\n  "cronExpression": "",\n  "misfirePolicy": "",\n  "concurrent": "",\n  "status": "",\n  "remark": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/job

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobName": "",
  "jobGroup": "",
  "invokeTarget": "",
  "cronExpression": "",
  "misfirePolicy": "",
  "concurrent": "",
  "status": "",
  "remark": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job")! 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()

DELETE 删除定时任务

{{baseUrl}}/monitor/job/:jobIds

QUERY PARAMS

jobIds

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/:jobIds");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/monitor/job/:jobIds")

require "http/client"

url = "{{baseUrl}}/monitor/job/:jobIds"

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}}/monitor/job/:jobIds"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/job/:jobIds");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job/:jobIds"

	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/monitor/job/:jobIds HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/job/:jobIds")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/:jobIds"))
    .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}}/monitor/job/:jobIds")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/job/:jobIds")
  .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}}/monitor/job/:jobIds');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/job/:jobIds'};

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

const url = '{{baseUrl}}/monitor/job/:jobIds';
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}}/monitor/job/:jobIds',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/:jobIds")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job/:jobIds',
  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}}/monitor/job/:jobIds'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/job/:jobIds');

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}}/monitor/job/:jobIds'};

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

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

const url = '{{baseUrl}}/monitor/job/:jobIds';
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}}/monitor/job/:jobIds"]
                                                       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}}/monitor/job/:jobIds" in

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

 "{{baseUrl}}/monitor/job/:jobIds",
  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}}/monitor/job/:jobIds');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/:jobIds');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/monitor/job/:jobIds');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job/:jobIds' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/:jobIds' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/monitor/job/:jobIds")

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

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

import requests

url = "{{baseUrl}}/monitor/job/:jobIds"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/:jobIds"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/:jobIds")

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/monitor/job/:jobIds') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/:jobIds";

    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}}/monitor/job/:jobIds

http DELETE {{baseUrl}}/monitor/job/:jobIds

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/job/:jobIds

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/:jobIds")! 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()

POST 导出定时任务为xlsx文件

{{baseUrl}}/monitor/job/export

BODY json

{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/export");

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  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/monitor/job/export" {:content-type :json
                                                               :form-params {:jobName ""
                                                                             :jobGroup ""
                                                                             :status ""}})

require "http/client"

url = "{{baseUrl}}/monitor/job/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\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}}/monitor/job/export"),
    Content = new StringContent("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/job/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job/export"

	payload := strings.NewReader("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/monitor/job/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitor/job/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/monitor/job/export")
  .header("content-type", "application/json")
  .body("{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobName: '',
  jobGroup: '',
  status: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/monitor/job/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/job/export',
  headers: {'content-type': 'application/json'},
  data: {jobName: '', jobGroup: '', status: ''}
};

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

const url = '{{baseUrl}}/monitor/job/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobGroup":"","status":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobName": "",\n  "jobGroup": "",\n  "status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/export")
  .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/monitor/job/export',
  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({jobName: '', jobGroup: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/job/export',
  headers: {'content-type': 'application/json'},
  body: {jobName: '', jobGroup: '', status: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/monitor/job/export');

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

req.type('json');
req.send({
  jobName: '',
  jobGroup: '',
  status: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/job/export',
  headers: {'content-type': 'application/json'},
  data: {jobName: '', jobGroup: '', status: ''}
};

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

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

const url = '{{baseUrl}}/monitor/job/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobGroup":"","status":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobName": @"",
                              @"jobGroup": @"",
                              @"status": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job/export"]
                                                       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}}/monitor/job/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}" in

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

 "{{baseUrl}}/monitor/job/export",
  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([
    'jobName' => '',
    'jobGroup' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/monitor/job/export', [
  'body' => '{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/export');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]));

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

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

append(json_encode([
  'jobName' => '',
  'jobGroup' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/job/export');
$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}}/monitor/job/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

import http.client

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

payload = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"

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

conn.request("POST", "/baseUrl/monitor/job/export", payload, headers)

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

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

import requests

url = "{{baseUrl}}/monitor/job/export"

payload = {
    "jobName": "",
    "jobGroup": "",
    "status": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/export"

payload <- "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/export")

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  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\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/monitor/job/export') do |req|
  req.body = "{\n  \"jobName\": \"\",\n  \"jobGroup\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/export";

    let payload = json!({
        "jobName": "",
        "jobGroup": "",
        "status": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/monitor/job/export \
  --header 'content-type: application/json' \
  --data '{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}'

echo '{
  "jobName": "",
  "jobGroup": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/monitor/job/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobName": "",\n  "jobGroup": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/job/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobName": "",
  "jobGroup": "",
  "status": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/export")! 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()

PUT 立即执行一次

{{baseUrl}}/monitor/job/run

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/run");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/monitor/job/run")

require "http/client"

url = "{{baseUrl}}/monitor/job/run"

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

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

var client = new RestClient("{{baseUrl}}/monitor/job/run");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/monitor/job/run"

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

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

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

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

}

PUT /baseUrl/monitor/job/run HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/monitor/job/run")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/run"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job/run")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/monitor/job/run")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/monitor/job/run');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/run'};

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

const url = '{{baseUrl}}/monitor/job/run';
const options = {method: 'PUT'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job/run',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/run")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job/run',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/run'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/monitor/job/run');

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

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

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

const options = {method: 'PUT', url: '{{baseUrl}}/monitor/job/run'};

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

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

const url = '{{baseUrl}}/monitor/job/run';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job/run"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/monitor/job/run" in

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

 "{{baseUrl}}/monitor/job/run",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/monitor/job/run');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/run');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/monitor/job/run');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job/run' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/run' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/monitor/job/run")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/job/run"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/run"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/run")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/monitor/job/run') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/run";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/monitor/job/run

http PUT {{baseUrl}}/monitor/job/run

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/monitor/job/run

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/run")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 获取定时任务列表

{{baseUrl}}/monitor/job/list

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/list");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/job/list")

require "http/client"

url = "{{baseUrl}}/monitor/job/list"

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}}/monitor/job/list"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/job/list");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/job/list"

	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/monitor/job/list HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/job/list")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/list"))
    .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}}/monitor/job/list")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/job/list")
  .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}}/monitor/job/list');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/job/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/job/list';
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}}/monitor/job/list',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/list")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job/list',
  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}}/monitor/job/list'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/job/list');

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}}/monitor/job/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/job/list';
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}}/monitor/job/list"]
                                                       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}}/monitor/job/list" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/job/list",
  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}}/monitor/job/list');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/list');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/job/list');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job/list' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/list' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/job/list")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/job/list"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/list"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/list")

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/monitor/job/list') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/list";

    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}}/monitor/job/list

http GET {{baseUrl}}/monitor/job/list

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/job/list

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 获取定时任务详细信息

{{baseUrl}}/monitor/job/:jobId

QUERY PARAMS

jobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/job/:jobId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/job/:jobId")

require "http/client"

url = "{{baseUrl}}/monitor/job/:jobId"

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}}/monitor/job/:jobId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/job/:jobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/job/:jobId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/monitor/job/:jobId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/job/:jobId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/job/:jobId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/job/:jobId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/job/:jobId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/monitor/job/:jobId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/job/:jobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/job/:jobId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/job/:jobId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/job/:jobId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/job/:jobId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/monitor/job/:jobId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/job/:jobId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/monitor/job/:jobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/job/:jobId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/job/:jobId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/monitor/job/:jobId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/job/:jobId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/monitor/job/:jobId');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/job/:jobId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/job/:jobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/job/:jobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/job/:jobId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/job/:jobId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/job/:jobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/job/:jobId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/job/:jobId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/monitor/job/:jobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/job/:jobId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/monitor/job/:jobId

http GET {{baseUrl}}/monitor/job/:jobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/job/:jobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/job/:jobId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 导出岗位管理xlsx文件

{{baseUrl}}/system/post/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/post/export" {:content-type :json
                                                               :form-params {:pageNum ""
                                                                             :pageSize ""
                                                                             :params ""
                                                                             :orderByColumn ""
                                                                             :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/post/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/post/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/post/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/post/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/post/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/post/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/post/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/post/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/post/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/post/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/post/export")
  .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/system/post/export',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/post/export',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  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}}/system/post/export');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/post/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/post/export"]
                                                       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}}/system/post/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/system/post/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/post/export');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/post/export');
$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}}/system/post/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/post/export", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/post/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/post/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/post/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/system/post/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/system/post/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/post/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 岗位管理-列表

{{baseUrl}}/system/post/list

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post/list?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/post/list" {:query-params {:pageNum ""
                                                                           :pageSize ""}
                                                            :content-type :json
                                                            :form-params {:pageNum ""
                                                                          :pageSize ""
                                                                          :params ""
                                                                          :orderByColumn ""
                                                                          :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/post/list?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/post/list?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/post/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post/list?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/system/post/list?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/post/list?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post/list?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/post/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/post/list?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/post/list?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/post/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/post/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/post/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/post/list?pageNum=&pageSize=',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/post/list',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/post/list');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/post/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/post/list?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/post/list?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post/list?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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('GET', '{{baseUrl}}/system/post/list?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/post/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/post/list');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/post/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/system/post/list?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post/list"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/post/list?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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.get('/baseUrl/system/post/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/post/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/post/list?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http GET '{{baseUrl}}/system/post/list?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/post/list?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 岗位管理-创建

{{baseUrl}}/system/post

BODY json

{
  "remark": "",
  "postSort": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post");

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  \"remark\": \"\",\n  \"postSort\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/post" {:content-type :json
                                                        :form-params {:remark ""
                                                                      :postSort ""}})

require "http/client"

url = "{{baseUrl}}/system/post"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/post"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/post");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"postSort\": \"\"\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/system/post HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "remark": "",
  "postSort": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/post")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"postSort\": \"\"\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  \"remark\": \"\",\n  \"postSort\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/post")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/post")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  postSort: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/post');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/post',
  headers: {'content-type': 'application/json'},
  data: {remark: '', postSort: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","postSort":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/post',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "postSort": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/post")
  .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/system/post',
  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({remark: '', postSort: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/post',
  headers: {'content-type': 'application/json'},
  body: {remark: '', postSort: ''},
  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}}/system/post');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  remark: '',
  postSort: ''
});

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}}/system/post',
  headers: {'content-type': 'application/json'},
  data: {remark: '', postSort: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","postSort":""}'
};

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 = @{ @"remark": @"",
                              @"postSort": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/post"]
                                                       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}}/system/post" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post",
  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([
    'remark' => '',
    'postSort' => ''
  ]),
  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}}/system/post', [
  'body' => '{
  "remark": "",
  "postSort": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/post');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'postSort' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'remark' => '',
  'postSort' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/post');
$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}}/system/post' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "postSort": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "postSort": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/post", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post"

payload = {
    "remark": "",
    "postSort": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post"

payload <- "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/post")

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  \"remark\": \"\",\n  \"postSort\": \"\"\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/system/post') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/post";

    let payload = json!({
        "remark": "",
        "postSort": ""
    });

    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}}/system/post \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "postSort": ""
}'

echo '{
  "remark": "",
  "postSort": ""
}' |  \
  http POST {{baseUrl}}/system/post \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "postSort": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/post

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "postSort": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post")! 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()

DELETE 岗位管理-删除

{{baseUrl}}/system/post/:ids

QUERY PARAMS

ids

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post/:ids");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/post/:ids")

require "http/client"

url = "{{baseUrl}}/system/post/:ids"

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}}/system/post/:ids"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/post/:ids");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post/:ids"

	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/system/post/:ids HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/post/:ids")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post/:ids"))
    .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}}/system/post/:ids")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/post/:ids")
  .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}}/system/post/:ids');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/post/:ids'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post/:ids';
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}}/system/post/:ids',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/post/:ids")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/post/:ids',
  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}}/system/post/:ids'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/system/post/:ids');

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}}/system/post/:ids'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post/:ids';
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}}/system/post/:ids"]
                                                       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}}/system/post/:ids" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post/:ids",
  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}}/system/post/:ids');

echo $response->getBody();

setUrl('{{baseUrl}}/system/post/:ids');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/post/:ids');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/post/:ids' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post/:ids' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/post/:ids")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post/:ids"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post/:ids"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/post/:ids")

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/system/post/:ids') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/post/:ids";

    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}}/system/post/:ids

http DELETE {{baseUrl}}/system/post/:ids

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/post/:ids

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post/:ids")! 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()

PUT 岗位管理-更新

{{baseUrl}}/system/post

BODY json

{
  "remark": "",
  "postSort": "",
  "postId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post");

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  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/post" {:content-type :json
                                                       :form-params {:remark ""
                                                                     :postSort ""
                                                                     :postId ""}})

require "http/client"

url = "{{baseUrl}}/system/post"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/post"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\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}}/system/post");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/post HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "remark": "",
  "postSort": "",
  "postId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/post")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\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  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/post")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/post")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  postSort: '',
  postId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/post');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/post',
  headers: {'content-type': 'application/json'},
  data: {remark: '', postSort: '', postId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","postSort":"","postId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/post',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "postSort": "",\n  "postId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/post")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/post',
  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({remark: '', postSort: '', postId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/post',
  headers: {'content-type': 'application/json'},
  body: {remark: '', postSort: '', postId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/post');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  remark: '',
  postSort: '',
  postId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/post',
  headers: {'content-type': 'application/json'},
  data: {remark: '', postSort: '', postId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","postSort":"","postId":""}'
};

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 = @{ @"remark": @"",
                              @"postSort": @"",
                              @"postId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/post"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/post" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'remark' => '',
    'postSort' => '',
    'postId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/post', [
  'body' => '{
  "remark": "",
  "postSort": "",
  "postId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/post');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'postSort' => '',
  'postId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'remark' => '',
  'postSort' => '',
  'postId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/post');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/post' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "postSort": "",
  "postId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "postSort": "",
  "postId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/post", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post"

payload = {
    "remark": "",
    "postSort": "",
    "postId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post"

payload <- "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/post")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\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.put('/baseUrl/system/post') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"postId\": \"\"\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}}/system/post";

    let payload = json!({
        "remark": "",
        "postSort": "",
        "postId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/post \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "postSort": "",
  "postId": ""
}'

echo '{
  "remark": "",
  "postSort": "",
  "postId": ""
}' |  \
  http PUT {{baseUrl}}/system/post \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "postSort": "",\n  "postId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/post

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "postSort": "",
  "postId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 岗位管理-详情

{{baseUrl}}/system/post/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/post/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/post/:id")

require "http/client"

url = "{{baseUrl}}/system/post/: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}}/system/post/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/post/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/post/: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/system/post/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/post/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/post/: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}}/system/post/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/post/: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}}/system/post/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/post/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/post/: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}}/system/post/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/post/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/post/: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}}/system/post/: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}}/system/post/: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}}/system/post/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/post/: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}}/system/post/: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}}/system/post/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/post/: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}}/system/post/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/post/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/post/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/post/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/post/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/post/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/post/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/post/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/post/: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/system/post/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/post/: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}}/system/post/:id

http GET {{baseUrl}}/system/post/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/post/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/post/: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()

POST 导出操作日志数据为xlsx

{{baseUrl}}/monitor/operlog/export

BODY json

{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/operlog/export");

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  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/monitor/operlog/export" {:content-type :json
                                                                   :form-params {:operId ""
                                                                                 :title ""
                                                                                 :businessType ""
                                                                                 :requestMethod ""
                                                                                 :operatorType ""
                                                                                 :operName ""
                                                                                 :deptName ""
                                                                                 :operUrl ""
                                                                                 :operLocation ""
                                                                                 :operParam ""
                                                                                 :jsonResult ""
                                                                                 :errorMsg ""
                                                                                 :method ""
                                                                                 :operIp ""
                                                                                 :operTime ""
                                                                                 :status ""
                                                                                 :costTime ""
                                                                                 :pageNum ""
                                                                                 :pageSize ""
                                                                                 :params ""
                                                                                 :orderByColumn ""
                                                                                 :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/monitor/operlog/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/monitor/operlog/export"),
    Content = new StringContent("{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/monitor/operlog/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/operlog/export"

	payload := strings.NewReader("{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/monitor/operlog/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 405

{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitor/operlog/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/operlog/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/monitor/operlog/export")
  .header("content-type", "application/json")
  .body("{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  operId: '',
  title: '',
  businessType: '',
  requestMethod: '',
  operatorType: '',
  operName: '',
  deptName: '',
  operUrl: '',
  operLocation: '',
  operParam: '',
  jsonResult: '',
  errorMsg: '',
  method: '',
  operIp: '',
  operTime: '',
  status: '',
  costTime: '',
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/monitor/operlog/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/operlog/export',
  headers: {'content-type': 'application/json'},
  data: {
    operId: '',
    title: '',
    businessType: '',
    requestMethod: '',
    operatorType: '',
    operName: '',
    deptName: '',
    operUrl: '',
    operLocation: '',
    operParam: '',
    jsonResult: '',
    errorMsg: '',
    method: '',
    operIp: '',
    operTime: '',
    status: '',
    costTime: '',
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/operlog/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"operId":"","title":"","businessType":"","requestMethod":"","operatorType":"","operName":"","deptName":"","operUrl":"","operLocation":"","operParam":"","jsonResult":"","errorMsg":"","method":"","operIp":"","operTime":"","status":"","costTime":"","pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/operlog/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "operId": "",\n  "title": "",\n  "businessType": "",\n  "requestMethod": "",\n  "operatorType": "",\n  "operName": "",\n  "deptName": "",\n  "operUrl": "",\n  "operLocation": "",\n  "operParam": "",\n  "jsonResult": "",\n  "errorMsg": "",\n  "method": "",\n  "operIp": "",\n  "operTime": "",\n  "status": "",\n  "costTime": "",\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/export")
  .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/monitor/operlog/export',
  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({
  operId: '',
  title: '',
  businessType: '',
  requestMethod: '',
  operatorType: '',
  operName: '',
  deptName: '',
  operUrl: '',
  operLocation: '',
  operParam: '',
  jsonResult: '',
  errorMsg: '',
  method: '',
  operIp: '',
  operTime: '',
  status: '',
  costTime: '',
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/operlog/export',
  headers: {'content-type': 'application/json'},
  body: {
    operId: '',
    title: '',
    businessType: '',
    requestMethod: '',
    operatorType: '',
    operName: '',
    deptName: '',
    operUrl: '',
    operLocation: '',
    operParam: '',
    jsonResult: '',
    errorMsg: '',
    method: '',
    operIp: '',
    operTime: '',
    status: '',
    costTime: '',
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: ''
  },
  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}}/monitor/operlog/export');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  operId: '',
  title: '',
  businessType: '',
  requestMethod: '',
  operatorType: '',
  operName: '',
  deptName: '',
  operUrl: '',
  operLocation: '',
  operParam: '',
  jsonResult: '',
  errorMsg: '',
  method: '',
  operIp: '',
  operTime: '',
  status: '',
  costTime: '',
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/monitor/operlog/export',
  headers: {'content-type': 'application/json'},
  data: {
    operId: '',
    title: '',
    businessType: '',
    requestMethod: '',
    operatorType: '',
    operName: '',
    deptName: '',
    operUrl: '',
    operLocation: '',
    operParam: '',
    jsonResult: '',
    errorMsg: '',
    method: '',
    operIp: '',
    operTime: '',
    status: '',
    costTime: '',
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/operlog/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"operId":"","title":"","businessType":"","requestMethod":"","operatorType":"","operName":"","deptName":"","operUrl":"","operLocation":"","operParam":"","jsonResult":"","errorMsg":"","method":"","operIp":"","operTime":"","status":"","costTime":"","pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"operId": @"",
                              @"title": @"",
                              @"businessType": @"",
                              @"requestMethod": @"",
                              @"operatorType": @"",
                              @"operName": @"",
                              @"deptName": @"",
                              @"operUrl": @"",
                              @"operLocation": @"",
                              @"operParam": @"",
                              @"jsonResult": @"",
                              @"errorMsg": @"",
                              @"method": @"",
                              @"operIp": @"",
                              @"operTime": @"",
                              @"status": @"",
                              @"costTime": @"",
                              @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/operlog/export"]
                                                       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}}/monitor/operlog/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/operlog/export",
  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([
    'operId' => '',
    'title' => '',
    'businessType' => '',
    'requestMethod' => '',
    'operatorType' => '',
    'operName' => '',
    'deptName' => '',
    'operUrl' => '',
    'operLocation' => '',
    'operParam' => '',
    'jsonResult' => '',
    'errorMsg' => '',
    'method' => '',
    'operIp' => '',
    'operTime' => '',
    'status' => '',
    'costTime' => '',
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/monitor/operlog/export', [
  'body' => '{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/operlog/export');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'operId' => '',
  'title' => '',
  'businessType' => '',
  'requestMethod' => '',
  'operatorType' => '',
  'operName' => '',
  'deptName' => '',
  'operUrl' => '',
  'operLocation' => '',
  'operParam' => '',
  'jsonResult' => '',
  'errorMsg' => '',
  'method' => '',
  'operIp' => '',
  'operTime' => '',
  'status' => '',
  'costTime' => '',
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'operId' => '',
  'title' => '',
  'businessType' => '',
  'requestMethod' => '',
  'operatorType' => '',
  'operName' => '',
  'deptName' => '',
  'operUrl' => '',
  'operLocation' => '',
  'operParam' => '',
  'jsonResult' => '',
  'errorMsg' => '',
  'method' => '',
  'operIp' => '',
  'operTime' => '',
  'status' => '',
  'costTime' => '',
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/operlog/export');
$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}}/monitor/operlog/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/operlog/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/monitor/operlog/export", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/operlog/export"

payload = {
    "operId": "",
    "title": "",
    "businessType": "",
    "requestMethod": "",
    "operatorType": "",
    "operName": "",
    "deptName": "",
    "operUrl": "",
    "operLocation": "",
    "operParam": "",
    "jsonResult": "",
    "errorMsg": "",
    "method": "",
    "operIp": "",
    "operTime": "",
    "status": "",
    "costTime": "",
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/operlog/export"

payload <- "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/monitor/operlog/export")

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  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/monitor/operlog/export') do |req|
  req.body = "{\n  \"operId\": \"\",\n  \"title\": \"\",\n  \"businessType\": \"\",\n  \"requestMethod\": \"\",\n  \"operatorType\": \"\",\n  \"operName\": \"\",\n  \"deptName\": \"\",\n  \"operUrl\": \"\",\n  \"operLocation\": \"\",\n  \"operParam\": \"\",\n  \"jsonResult\": \"\",\n  \"errorMsg\": \"\",\n  \"method\": \"\",\n  \"operIp\": \"\",\n  \"operTime\": \"\",\n  \"status\": \"\",\n  \"costTime\": \"\",\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/operlog/export";

    let payload = json!({
        "operId": "",
        "title": "",
        "businessType": "",
        "requestMethod": "",
        "operatorType": "",
        "operName": "",
        "deptName": "",
        "operUrl": "",
        "operLocation": "",
        "operParam": "",
        "jsonResult": "",
        "errorMsg": "",
        "method": "",
        "operIp": "",
        "operTime": "",
        "status": "",
        "costTime": "",
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/monitor/operlog/export \
  --header 'content-type: application/json' \
  --data '{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/monitor/operlog/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "operId": "",\n  "title": "",\n  "businessType": "",\n  "requestMethod": "",\n  "operatorType": "",\n  "operName": "",\n  "deptName": "",\n  "operUrl": "",\n  "operLocation": "",\n  "operParam": "",\n  "jsonResult": "",\n  "errorMsg": "",\n  "method": "",\n  "operIp": "",\n  "operTime": "",\n  "status": "",\n  "costTime": "",\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/operlog/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "operId": "",
  "title": "",
  "businessType": "",
  "requestMethod": "",
  "operatorType": "",
  "operName": "",
  "deptName": "",
  "operUrl": "",
  "operLocation": "",
  "operParam": "",
  "jsonResult": "",
  "errorMsg": "",
  "method": "",
  "operIp": "",
  "operTime": "",
  "status": "",
  "costTime": "",
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/operlog/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 操作日志-列表

{{baseUrl}}/monitor/operlog/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/operlog/list" {:query-params {:pageNum ""
                                                                               :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize="

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}}/monitor/operlog/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize="

	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/monitor/operlog/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize="))
    .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}}/monitor/operlog/list?pageNum=&pageSize=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=")
  .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}}/monitor/operlog/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/operlog/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=';
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}}/monitor/operlog/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/operlog/list?pageNum=&pageSize=',
  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}}/monitor/operlog/list',
  qs: {pageNum: '', pageSize: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/operlog/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/monitor/operlog/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=';
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}}/monitor/operlog/list?pageNum=&pageSize="]
                                                       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}}/monitor/operlog/list?pageNum=&pageSize=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=",
  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}}/monitor/operlog/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/operlog/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/operlog/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/operlog/list?pageNum=&pageSize=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/operlog/list"

querystring = {"pageNum":"","pageSize":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/operlog/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=")

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/monitor/operlog/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/operlog/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/monitor/operlog/list?pageNum=&pageSize='

http GET '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/operlog/list?pageNum=&pageSize=")! 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()

DELETE 操作日志-删除

{{baseUrl}}/monitor/operlog/:operId

QUERY PARAMS

operId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/operlog/:operId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/operlog/:operId")

require "http/client"

url = "{{baseUrl}}/monitor/operlog/:operId"

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}}/monitor/operlog/:operId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/operlog/:operId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/operlog/:operId"

	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/monitor/operlog/:operId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/operlog/:operId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/operlog/:operId"))
    .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}}/monitor/operlog/:operId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/operlog/:operId")
  .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}}/monitor/operlog/:operId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/operlog/:operId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/operlog/:operId';
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}}/monitor/operlog/:operId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/:operId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/operlog/:operId',
  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}}/monitor/operlog/:operId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/operlog/:operId');

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}}/monitor/operlog/:operId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/operlog/:operId';
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}}/monitor/operlog/:operId"]
                                                       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}}/monitor/operlog/:operId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/operlog/:operId",
  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}}/monitor/operlog/:operId');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/operlog/:operId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/operlog/:operId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/operlog/:operId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/operlog/:operId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/operlog/:operId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/operlog/:operId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/operlog/:operId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/operlog/:operId")

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/monitor/operlog/:operId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/operlog/:operId";

    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}}/monitor/operlog/:operId

http DELETE {{baseUrl}}/monitor/operlog/:operId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/operlog/:operId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/operlog/:operId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE 操作日志-清除全部日志

{{baseUrl}}/monitor/operlog/clean

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/operlog/clean");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/operlog/clean")

require "http/client"

url = "{{baseUrl}}/monitor/operlog/clean"

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}}/monitor/operlog/clean"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/operlog/clean");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/operlog/clean"

	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/monitor/operlog/clean HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/operlog/clean")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/operlog/clean"))
    .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}}/monitor/operlog/clean")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/operlog/clean")
  .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}}/monitor/operlog/clean');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/operlog/clean'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/operlog/clean';
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}}/monitor/operlog/clean',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/clean")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/operlog/clean',
  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}}/monitor/operlog/clean'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/operlog/clean');

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}}/monitor/operlog/clean'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/operlog/clean';
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}}/monitor/operlog/clean"]
                                                       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}}/monitor/operlog/clean" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/operlog/clean",
  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}}/monitor/operlog/clean');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/operlog/clean');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/operlog/clean');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/operlog/clean' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/operlog/clean' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/operlog/clean")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/operlog/clean"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/operlog/clean"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/operlog/clean")

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/monitor/operlog/clean') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/operlog/clean";

    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}}/monitor/operlog/clean

http DELETE {{baseUrl}}/monitor/operlog/clean

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/operlog/clean

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/operlog/clean")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 操作日志记录-详情

{{baseUrl}}/monitor/operlog/:operId

QUERY PARAMS

operId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/operlog/:operId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/operlog/:operId")

require "http/client"

url = "{{baseUrl}}/monitor/operlog/:operId"

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}}/monitor/operlog/:operId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/operlog/:operId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/operlog/:operId"

	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/monitor/operlog/:operId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/operlog/:operId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/operlog/:operId"))
    .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}}/monitor/operlog/:operId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/operlog/:operId")
  .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}}/monitor/operlog/:operId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/operlog/:operId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/operlog/:operId';
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}}/monitor/operlog/:operId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/operlog/:operId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/operlog/:operId',
  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}}/monitor/operlog/:operId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/operlog/:operId');

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}}/monitor/operlog/:operId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/operlog/:operId';
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}}/monitor/operlog/:operId"]
                                                       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}}/monitor/operlog/:operId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/operlog/:operId",
  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}}/monitor/operlog/:operId');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/operlog/:operId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/operlog/:operId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/operlog/:operId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/operlog/:operId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/operlog/:operId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/operlog/:operId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/operlog/:operId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/operlog/:operId")

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/monitor/operlog/:operId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/operlog/:operId";

    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}}/monitor/operlog/:operId

http GET {{baseUrl}}/monitor/operlog/:operId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/operlog/:operId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/operlog/:operId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 用户信息

{{baseUrl}}/getInfo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getInfo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/getInfo")

require "http/client"

url = "{{baseUrl}}/getInfo"

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}}/getInfo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/getInfo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/getInfo"

	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/getInfo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getInfo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getInfo"))
    .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}}/getInfo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/getInfo")
  .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}}/getInfo');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/getInfo'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/getInfo';
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}}/getInfo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/getInfo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/getInfo',
  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}}/getInfo'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/getInfo');

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}}/getInfo'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/getInfo';
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}}/getInfo"]
                                                       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}}/getInfo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/getInfo",
  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}}/getInfo');

echo $response->getBody();

setUrl('{{baseUrl}}/getInfo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/getInfo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/getInfo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/getInfo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/getInfo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/getInfo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/getInfo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/getInfo")

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/getInfo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/getInfo";

    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}}/getInfo

http GET {{baseUrl}}/getInfo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/getInfo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getInfo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 用户注册

{{baseUrl}}/register

BODY json

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/register");

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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/register" {:content-type :json
                                                     :form-params {:code ""
                                                                   :userName ""
                                                                   :password ""
                                                                   :uuid ""}})

require "http/client"

url = "{{baseUrl}}/register"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/register"),
    Content = new StringContent("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/register");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/register"

	payload := strings.NewReader("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/register HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/register")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/register"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/register")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/register")
  .header("content-type", "application/json")
  .body("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/register');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/register',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/register',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/register")
  .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/register',
  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({code: '', userName: '', password: '', uuid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/register',
  headers: {'content-type': 'application/json'},
  body: {code: '', userName: '', password: '', uuid: ''},
  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}}/register');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

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}}/register',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

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 = @{ @"code": @"",
                              @"userName": @"",
                              @"password": @"",
                              @"uuid": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/register"]
                                                       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}}/register" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/register",
  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([
    'code' => '',
    'userName' => '',
    'password' => '',
    'uuid' => ''
  ]),
  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}}/register', [
  'body' => '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/register');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/register');
$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}}/register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/register", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/register"

payload = {
    "code": "",
    "userName": "",
    "password": "",
    "uuid": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/register"

payload <- "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/register")

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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/register') do |req|
  req.body = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/register";

    let payload = json!({
        "code": "",
        "userName": "",
        "password": "",
        "uuid": ""
    });

    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}}/register \
  --header 'content-type: application/json' \
  --data '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

echo '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}' |  \
  http POST {{baseUrl}}/register \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/register

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/register")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 用户登录

{{baseUrl}}/login

BODY json

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/login" {:content-type :json
                                                  :form-params {:code ""
                                                                :userName ""
                                                                :password ""
                                                                :uuid ""}})

require "http/client"

url = "{{baseUrl}}/login"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/login"),
    Content = new StringContent("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/login");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/login"

	payload := strings.NewReader("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/login HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/login")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/login"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/login")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/login")
  .header("content-type", "application/json")
  .body("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/login');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/login',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/login',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/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/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({code: '', userName: '', password: '', uuid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/login',
  headers: {'content-type': 'application/json'},
  body: {code: '', userName: '', password: '', uuid: ''},
  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}}/login');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

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}}/login',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

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 = @{ @"code": @"",
                              @"userName": @"",
                              @"password": @"",
                              @"uuid": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/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}}/login" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/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([
    'code' => '',
    'userName' => '',
    'password' => '',
    'uuid' => ''
  ]),
  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}}/login', [
  'body' => '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/login');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/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}}/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/login", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/login"

payload = {
    "code": "",
    "userName": "",
    "password": "",
    "uuid": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/login"

payload <- "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/login') do |req|
  req.body = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/login";

    let payload = json!({
        "code": "",
        "userName": "",
        "password": "",
        "uuid": ""
    });

    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}}/login \
  --header 'content-type: application/json' \
  --data '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

echo '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}' |  \
  http POST {{baseUrl}}/login \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/login

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/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()

GET 获取验证图片

{{baseUrl}}/captchaImage

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/captchaImage");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/captchaImage")

require "http/client"

url = "{{baseUrl}}/captchaImage"

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}}/captchaImage"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/captchaImage");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/captchaImage"

	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/captchaImage HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/captchaImage")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/captchaImage"))
    .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}}/captchaImage")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/captchaImage")
  .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}}/captchaImage');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/captchaImage'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/captchaImage';
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}}/captchaImage',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/captchaImage")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/captchaImage',
  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}}/captchaImage'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/captchaImage');

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}}/captchaImage'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/captchaImage';
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}}/captchaImage"]
                                                       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}}/captchaImage" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/captchaImage",
  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}}/captchaImage');

echo $response->getBody();

setUrl('{{baseUrl}}/captchaImage');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/captchaImage');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/captchaImage' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/captchaImage' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/captchaImage")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/captchaImage"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/captchaImage"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/captchaImage")

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/captchaImage') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/captchaImage";

    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}}/captchaImage

http GET {{baseUrl}}/captchaImage

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/captchaImage

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/captchaImage")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 账号自助-是否开启用户注册功能

{{baseUrl}}/registerUser

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registerUser");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/registerUser")

require "http/client"

url = "{{baseUrl}}/registerUser"

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}}/registerUser"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/registerUser");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/registerUser"

	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/registerUser HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/registerUser")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/registerUser"))
    .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}}/registerUser")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/registerUser")
  .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}}/registerUser');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/registerUser'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/registerUser';
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}}/registerUser',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/registerUser")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/registerUser',
  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}}/registerUser'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/registerUser');

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}}/registerUser'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/registerUser';
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}}/registerUser"]
                                                       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}}/registerUser" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/registerUser",
  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}}/registerUser');

echo $response->getBody();

setUrl('{{baseUrl}}/registerUser');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/registerUser');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/registerUser' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/registerUser' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/registerUser")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/registerUser"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/registerUser"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/registerUser")

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/registerUser') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/registerUser";

    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}}/registerUser

http GET {{baseUrl}}/registerUser

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/registerUser

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registerUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 路由信息

{{baseUrl}}/getRouters

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getRouters");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/getRouters")

require "http/client"

url = "{{baseUrl}}/getRouters"

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}}/getRouters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/getRouters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/getRouters"

	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/getRouters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getRouters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/getRouters"))
    .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}}/getRouters")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/getRouters")
  .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}}/getRouters');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/getRouters'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/getRouters';
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}}/getRouters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/getRouters")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/getRouters',
  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}}/getRouters'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/getRouters');

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}}/getRouters'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/getRouters';
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}}/getRouters"]
                                                       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}}/getRouters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/getRouters",
  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}}/getRouters');

echo $response->getBody();

setUrl('{{baseUrl}}/getRouters');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/getRouters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/getRouters' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/getRouters' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/getRouters")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/getRouters"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/getRouters"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/getRouters")

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/getRouters') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/getRouters";

    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}}/getRouters

http GET {{baseUrl}}/getRouters

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/getRouters

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getRouters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 退出登录

{{baseUrl}}/logout

BODY json

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/logout");

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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/logout" {:content-type :json
                                                   :form-params {:code ""
                                                                 :userName ""
                                                                 :password ""
                                                                 :uuid ""}})

require "http/client"

url = "{{baseUrl}}/logout"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/logout"),
    Content = new StringContent("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/logout");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/logout"

	payload := strings.NewReader("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/logout HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/logout")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/logout"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/logout")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/logout")
  .header("content-type", "application/json")
  .body("{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/logout');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/logout',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/logout';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/logout',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/logout")
  .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/logout',
  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({code: '', userName: '', password: '', uuid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/logout',
  headers: {'content-type': 'application/json'},
  body: {code: '', userName: '', password: '', uuid: ''},
  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}}/logout');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: '',
  userName: '',
  password: '',
  uuid: ''
});

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}}/logout',
  headers: {'content-type': 'application/json'},
  data: {code: '', userName: '', password: '', uuid: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/logout';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"","userName":"","password":"","uuid":""}'
};

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 = @{ @"code": @"",
                              @"userName": @"",
                              @"password": @"",
                              @"uuid": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/logout"]
                                                       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}}/logout" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/logout",
  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([
    'code' => '',
    'userName' => '',
    'password' => '',
    'uuid' => ''
  ]),
  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}}/logout', [
  'body' => '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/logout');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => '',
  'userName' => '',
  'password' => '',
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/logout');
$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}}/logout' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/logout' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/logout", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/logout"

payload = {
    "code": "",
    "userName": "",
    "password": "",
    "uuid": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/logout"

payload <- "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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}}/logout")

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  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\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/logout') do |req|
  req.body = "{\n  \"code\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"uuid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/logout";

    let payload = json!({
        "code": "",
        "userName": "",
        "password": "",
        "uuid": ""
    });

    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}}/logout \
  --header 'content-type: application/json' \
  --data '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}'

echo '{
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
}' |  \
  http POST {{baseUrl}}/logout \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": "",\n  "userName": "",\n  "password": "",\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/logout

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": "",
  "userName": "",
  "password": "",
  "uuid": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/logout")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 个人中心-上传用户头像

{{baseUrl}}/system/user/profile/avatar

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/profile/avatar");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/user/profile/avatar")

require "http/client"

url = "{{baseUrl}}/system/user/profile/avatar"

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}}/system/user/profile/avatar"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/profile/avatar");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/profile/avatar"

	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/system/user/profile/avatar HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/user/profile/avatar")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/profile/avatar"))
    .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}}/system/user/profile/avatar")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/user/profile/avatar")
  .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}}/system/user/profile/avatar');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/system/user/profile/avatar'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/profile/avatar';
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}}/system/user/profile/avatar',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/profile/avatar")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/profile/avatar',
  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}}/system/user/profile/avatar'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/user/profile/avatar');

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}}/system/user/profile/avatar'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/profile/avatar';
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}}/system/user/profile/avatar"]
                                                       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}}/system/user/profile/avatar" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/profile/avatar",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/system/user/profile/avatar');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/profile/avatar');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/profile/avatar');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/profile/avatar' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/profile/avatar' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/system/user/profile/avatar")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/profile/avatar"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/profile/avatar"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/profile/avatar")

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/system/user/profile/avatar') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/profile/avatar";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/user/profile/avatar

http POST {{baseUrl}}/system/user/profile/avatar

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/system/user/profile/avatar

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/profile/avatar")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 个人中心-修改密码

{{baseUrl}}/system/user/profile/updatePwd

BODY json

{
  "oldPassword": "",
  "newPassword": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/profile/updatePwd");

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  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user/profile/updatePwd" {:content-type :json
                                                                         :form-params {:oldPassword ""
                                                                                       :newPassword ""}})

require "http/client"

url = "{{baseUrl}}/system/user/profile/updatePwd"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user/profile/updatePwd"),
    Content = new StringContent("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\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}}/system/user/profile/updatePwd");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/profile/updatePwd"

	payload := strings.NewReader("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user/profile/updatePwd HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "oldPassword": "",
  "newPassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user/profile/updatePwd")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/profile/updatePwd"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\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  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/profile/updatePwd")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user/profile/updatePwd")
  .header("content-type", "application/json")
  .body("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  oldPassword: '',
  newPassword: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user/profile/updatePwd');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile/updatePwd',
  headers: {'content-type': 'application/json'},
  data: {oldPassword: '', newPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/profile/updatePwd';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"oldPassword":"","newPassword":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user/profile/updatePwd',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "oldPassword": "",\n  "newPassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user/profile/updatePwd")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/profile/updatePwd',
  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({oldPassword: '', newPassword: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile/updatePwd',
  headers: {'content-type': 'application/json'},
  body: {oldPassword: '', newPassword: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/user/profile/updatePwd');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  oldPassword: '',
  newPassword: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile/updatePwd',
  headers: {'content-type': 'application/json'},
  data: {oldPassword: '', newPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/profile/updatePwd';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"oldPassword":"","newPassword":""}'
};

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 = @{ @"oldPassword": @"",
                              @"newPassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/profile/updatePwd"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user/profile/updatePwd" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/profile/updatePwd",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'oldPassword' => '',
    'newPassword' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/user/profile/updatePwd', [
  'body' => '{
  "oldPassword": "",
  "newPassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/profile/updatePwd');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'oldPassword' => '',
  'newPassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'oldPassword' => '',
  'newPassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user/profile/updatePwd');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/profile/updatePwd' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "oldPassword": "",
  "newPassword": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/profile/updatePwd' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "oldPassword": "",
  "newPassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/user/profile/updatePwd", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/profile/updatePwd"

payload = {
    "oldPassword": "",
    "newPassword": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/profile/updatePwd"

payload <- "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/profile/updatePwd")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\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.put('/baseUrl/system/user/profile/updatePwd') do |req|
  req.body = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\"\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}}/system/user/profile/updatePwd";

    let payload = json!({
        "oldPassword": "",
        "newPassword": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user/profile/updatePwd \
  --header 'content-type: application/json' \
  --data '{
  "oldPassword": "",
  "newPassword": ""
}'

echo '{
  "oldPassword": "",
  "newPassword": ""
}' |  \
  http PUT {{baseUrl}}/system/user/profile/updatePwd \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "oldPassword": "",\n  "newPassword": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user/profile/updatePwd

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "oldPassword": "",
  "newPassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/profile/updatePwd")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 个人中心-修改用户信息

{{baseUrl}}/system/user/profile

BODY json

{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/profile");

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  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user/profile" {:content-type :json
                                                               :form-params {:nickName ""
                                                                             :email ""
                                                                             :phonenumber ""
                                                                             :sex ""
                                                                             :avatar ""}})

require "http/client"

url = "{{baseUrl}}/system/user/profile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user/profile"),
    Content = new StringContent("{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\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}}/system/user/profile");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/profile"

	payload := strings.NewReader("{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user/profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 85

{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user/profile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/profile"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\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  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/profile")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user/profile")
  .header("content-type", "application/json")
  .body("{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nickName: '',
  email: '',
  phonenumber: '',
  sex: '',
  avatar: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user/profile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile',
  headers: {'content-type': 'application/json'},
  data: {nickName: '', email: '', phonenumber: '', sex: '', avatar: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/profile';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"nickName":"","email":"","phonenumber":"","sex":"","avatar":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user/profile',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nickName": "",\n  "email": "",\n  "phonenumber": "",\n  "sex": "",\n  "avatar": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user/profile")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/profile',
  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({nickName: '', email: '', phonenumber: '', sex: '', avatar: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile',
  headers: {'content-type': 'application/json'},
  body: {nickName: '', email: '', phonenumber: '', sex: '', avatar: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/user/profile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nickName: '',
  email: '',
  phonenumber: '',
  sex: '',
  avatar: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/profile',
  headers: {'content-type': 'application/json'},
  data: {nickName: '', email: '', phonenumber: '', sex: '', avatar: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/profile';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"nickName":"","email":"","phonenumber":"","sex":"","avatar":""}'
};

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 = @{ @"nickName": @"",
                              @"email": @"",
                              @"phonenumber": @"",
                              @"sex": @"",
                              @"avatar": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/profile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user/profile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/profile",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'nickName' => '',
    'email' => '',
    'phonenumber' => '',
    'sex' => '',
    'avatar' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/user/profile', [
  'body' => '{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/profile');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nickName' => '',
  'email' => '',
  'phonenumber' => '',
  'sex' => '',
  'avatar' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nickName' => '',
  'email' => '',
  'phonenumber' => '',
  'sex' => '',
  'avatar' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user/profile');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/profile' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/profile' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/user/profile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/profile"

payload = {
    "nickName": "",
    "email": "",
    "phonenumber": "",
    "sex": "",
    "avatar": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/profile"

payload <- "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/profile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\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.put('/baseUrl/system/user/profile') do |req|
  req.body = "{\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"phonenumber\": \"\",\n  \"sex\": \"\",\n  \"avatar\": \"\"\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}}/system/user/profile";

    let payload = json!({
        "nickName": "",
        "email": "",
        "phonenumber": "",
        "sex": "",
        "avatar": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user/profile \
  --header 'content-type: application/json' \
  --data '{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}'

echo '{
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
}' |  \
  http PUT {{baseUrl}}/system/user/profile \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "nickName": "",\n  "email": "",\n  "phonenumber": "",\n  "sex": "",\n  "avatar": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user/profile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "nickName": "",
  "email": "",
  "phonenumber": "",
  "sex": "",
  "avatar": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/profile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 个人中心-用户信息

{{baseUrl}}/system/user/profile

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/profile");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user/profile")

require "http/client"

url = "{{baseUrl}}/system/user/profile"

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}}/system/user/profile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/profile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/profile"

	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/system/user/profile HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user/profile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/profile"))
    .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}}/system/user/profile")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user/profile")
  .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}}/system/user/profile');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/user/profile'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/profile';
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}}/system/user/profile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/profile")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/profile',
  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}}/system/user/profile'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/user/profile');

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}}/system/user/profile'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/profile';
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}}/system/user/profile"]
                                                       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}}/system/user/profile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/profile",
  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}}/system/user/profile');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/profile');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/profile');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/profile' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/profile' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user/profile")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/profile"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/profile"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/profile")

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/system/user/profile') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/profile";

    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}}/system/user/profile

http GET {{baseUrl}}/system/user/profile

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/user/profile

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/profile")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 导出用户信息数据为xlsx

{{baseUrl}}/system/user/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/user/export" {:content-type :json
                                                               :form-params {:pageNum ""
                                                                             :pageSize ""
                                                                             :params ""
                                                                             :orderByColumn ""
                                                                             :isAsc ""
                                                                             :deptId ""
                                                                             :nickName ""
                                                                             :email ""
                                                                             :userName ""
                                                                             :phonenumber ""
                                                                             :status ""}})

require "http/client"

url = "{{baseUrl}}/system/user/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\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}}/system/user/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/system/user/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 195

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/user/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/user/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  deptId: '',
  nickName: '',
  email: '',
  userName: '',
  phonenumber: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/user/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/user/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    deptId: '',
    nickName: '',
    email: '',
    userName: '',
    phonenumber: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","deptId":"","nickName":"","email":"","userName":"","phonenumber":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "deptId": "",\n  "nickName": "",\n  "email": "",\n  "userName": "",\n  "phonenumber": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user/export")
  .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/system/user/export',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  deptId: '',
  nickName: '',
  email: '',
  userName: '',
  phonenumber: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/user/export',
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    deptId: '',
    nickName: '',
    email: '',
    userName: '',
    phonenumber: '',
    status: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/user/export');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  deptId: '',
  nickName: '',
  email: '',
  userName: '',
  phonenumber: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/user/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    deptId: '',
    nickName: '',
    email: '',
    userName: '',
    phonenumber: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","deptId":"","nickName":"","email":"","userName":"","phonenumber":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"deptId": @"",
                              @"nickName": @"",
                              @"email": @"",
                              @"userName": @"",
                              @"phonenumber": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/export"]
                                                       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}}/system/user/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'deptId' => '',
    'nickName' => '',
    'email' => '',
    'userName' => '',
    'phonenumber' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/system/user/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/export');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'deptId' => '',
  'nickName' => '',
  'email' => '',
  'userName' => '',
  'phonenumber' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'deptId' => '',
  'nickName' => '',
  'email' => '',
  'userName' => '',
  'phonenumber' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user/export');
$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}}/system/user/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/user/export", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "deptId": "",
    "nickName": "",
    "email": "",
    "userName": "",
    "phonenumber": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\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/system/user/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"deptId\": \"\",\n  \"nickName\": \"\",\n  \"email\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "deptId": "",
        "nickName": "",
        "email": "",
        "userName": "",
        "phonenumber": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/user/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/system/user/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "deptId": "",\n  "nickName": "",\n  "email": "",\n  "userName": "",\n  "phonenumber": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "deptId": "",
  "nickName": "",
  "email": "",
  "userName": "",
  "phonenumber": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/export")! 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()

PUT 用户-停用角色

{{baseUrl}}/system/user/changeStatus

BODY json

{
  "userId": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/changeStatus");

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  \"userId\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user/changeStatus" {:content-type :json
                                                                    :form-params {:userId ""
                                                                                  :status ""}})

require "http/client"

url = "{{baseUrl}}/system/user/changeStatus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user/changeStatus"),
    Content = new StringContent("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/changeStatus");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/changeStatus"

	payload := strings.NewReader("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user/changeStatus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "userId": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user/changeStatus")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/changeStatus"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/changeStatus")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user/changeStatus")
  .header("content-type", "application/json")
  .body("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  userId: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user/changeStatus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/changeStatus',
  headers: {'content-type': 'application/json'},
  data: {userId: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/changeStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user/changeStatus',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "userId": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user/changeStatus")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/changeStatus',
  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({userId: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/changeStatus',
  headers: {'content-type': 'application/json'},
  body: {userId: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/user/changeStatus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  userId: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/changeStatus',
  headers: {'content-type': 'application/json'},
  data: {userId: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/changeStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"userId": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/changeStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user/changeStatus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/changeStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'userId' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/user/changeStatus', [
  'body' => '{
  "userId": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/changeStatus');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'userId' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'userId' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user/changeStatus');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/changeStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/changeStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/user/changeStatus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/changeStatus"

payload = {
    "userId": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/changeStatus"

payload <- "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/changeStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"userId\": \"\",\n  \"status\": \"\"\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.put('/baseUrl/system/user/changeStatus') do |req|
  req.body = "{\n  \"userId\": \"\",\n  \"status\": \"\"\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}}/system/user/changeStatus";

    let payload = json!({
        "userId": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user/changeStatus \
  --header 'content-type: application/json' \
  --data '{
  "userId": "",
  "status": ""
}'

echo '{
  "userId": "",
  "status": ""
}' |  \
  http PUT {{baseUrl}}/system/user/changeStatus \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "userId": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user/changeStatus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "userId": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/changeStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 用户-分配角色-详情

{{baseUrl}}/system/user/authRole/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/authRole/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user/authRole/:id")

require "http/client"

url = "{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/authRole/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/authRole/: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/system/user/authRole/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user/authRole/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/user/authRole/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/authRole/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/authRole/: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}}/system/user/authRole/: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}}/system/user/authRole/: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}}/system/user/authRole/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/: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}}/system/user/authRole/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/authRole/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/authRole/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/authRole/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/authRole/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user/authRole/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/authRole/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/authRole/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/authRole/: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/system/user/authRole/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/authRole/: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}}/system/user/authRole/:id

http GET {{baseUrl}}/system/user/authRole/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/user/authRole/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/authRole/: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()

GET 用户-列表

{{baseUrl}}/system/user/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user/list" {:query-params {:pageNum ""
                                                                           :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/system/user/list?pageNum=&pageSize="

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}}/system/user/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/list?pageNum=&pageSize="

	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/system/user/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/list?pageNum=&pageSize="))
    .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}}/system/user/list?pageNum=&pageSize=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user/list?pageNum=&pageSize=")
  .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}}/system/user/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/user/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/list?pageNum=&pageSize=';
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}}/system/user/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/list?pageNum=&pageSize=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/list?pageNum=&pageSize=',
  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}}/system/user/list',
  qs: {pageNum: '', pageSize: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/user/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/system/user/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/list?pageNum=&pageSize=';
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}}/system/user/list?pageNum=&pageSize="]
                                                       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}}/system/user/list?pageNum=&pageSize=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/list?pageNum=&pageSize=",
  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}}/system/user/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/list?pageNum=&pageSize=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user/list?pageNum=&pageSize=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/list"

querystring = {"pageNum":"","pageSize":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/list?pageNum=&pageSize=")

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/system/user/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/system/user/list?pageNum=&pageSize='

http GET '{{baseUrl}}/system/user/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/system/user/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 用户-创建

{{baseUrl}}/system/user

BODY json

{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/user" {:content-type :json
                                                        :form-params {:deptId ""
                                                                      :email ""
                                                                      :nickName ""
                                                                      :userName ""
                                                                      :password ""
                                                                      :phonenumber ""
                                                                      :postIds []
                                                                      :roleIds []
                                                                      :status ""
                                                                      :sex ""
                                                                      :remark ""
                                                                      :postSort ""}})

require "http/client"

url = "{{baseUrl}}/system/user"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/user"),
    Content = new StringContent("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/user");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user"

	payload := strings.NewReader("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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/system/user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 205

{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/user")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/user")
  .header("content-type", "application/json")
  .body("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/user');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/user',
  headers: {'content-type': 'application/json'},
  data: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deptId":"","email":"","nickName":"","userName":"","password":"","phonenumber":"","postIds":[],"roleIds":[],"status":"","sex":"","remark":"","postSort":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deptId": "",\n  "email": "",\n  "nickName": "",\n  "userName": "",\n  "password": "",\n  "phonenumber": "",\n  "postIds": [],\n  "roleIds": [],\n  "status": "",\n  "sex": "",\n  "remark": "",\n  "postSort": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user")
  .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/system/user',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/user',
  headers: {'content-type': 'application/json'},
  body: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: ''
  },
  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}}/system/user');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: ''
});

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}}/system/user',
  headers: {'content-type': 'application/json'},
  data: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deptId":"","email":"","nickName":"","userName":"","password":"","phonenumber":"","postIds":[],"roleIds":[],"status":"","sex":"","remark":"","postSort":""}'
};

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 = @{ @"deptId": @"",
                              @"email": @"",
                              @"nickName": @"",
                              @"userName": @"",
                              @"password": @"",
                              @"phonenumber": @"",
                              @"postIds": @[  ],
                              @"roleIds": @[  ],
                              @"status": @"",
                              @"sex": @"",
                              @"remark": @"",
                              @"postSort": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user"]
                                                       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}}/system/user" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user",
  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([
    'deptId' => '',
    'email' => '',
    'nickName' => '',
    'userName' => '',
    'password' => '',
    'phonenumber' => '',
    'postIds' => [
        
    ],
    'roleIds' => [
        
    ],
    'status' => '',
    'sex' => '',
    'remark' => '',
    'postSort' => ''
  ]),
  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}}/system/user', [
  'body' => '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deptId' => '',
  'email' => '',
  'nickName' => '',
  'userName' => '',
  'password' => '',
  'phonenumber' => '',
  'postIds' => [
    
  ],
  'roleIds' => [
    
  ],
  'status' => '',
  'sex' => '',
  'remark' => '',
  'postSort' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deptId' => '',
  'email' => '',
  'nickName' => '',
  'userName' => '',
  'password' => '',
  'phonenumber' => '',
  'postIds' => [
    
  ],
  'roleIds' => [
    
  ],
  'status' => '',
  'sex' => '',
  'remark' => '',
  'postSort' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user');
$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}}/system/user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/user", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user"

payload = {
    "deptId": "",
    "email": "",
    "nickName": "",
    "userName": "",
    "password": "",
    "phonenumber": "",
    "postIds": [],
    "roleIds": [],
    "status": "",
    "sex": "",
    "remark": "",
    "postSort": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user"

payload <- "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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}}/system/user")

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  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\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/system/user') do |req|
  req.body = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user";

    let payload = json!({
        "deptId": "",
        "email": "",
        "nickName": "",
        "userName": "",
        "password": "",
        "phonenumber": "",
        "postIds": (),
        "roleIds": (),
        "status": "",
        "sex": "",
        "remark": "",
        "postSort": ""
    });

    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}}/system/user \
  --header 'content-type: application/json' \
  --data '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}'

echo '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
}' |  \
  http POST {{baseUrl}}/system/user \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "deptId": "",\n  "email": "",\n  "nickName": "",\n  "userName": "",\n  "password": "",\n  "phonenumber": "",\n  "postIds": [],\n  "roleIds": [],\n  "status": "",\n  "sex": "",\n  "remark": "",\n  "postSort": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user")! 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()

DELETE 用户-删除

{{baseUrl}}/system/user/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/user/:id")

require "http/client"

url = "{{baseUrl}}/system/user/: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}}/system/user/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/: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/system/user/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/user/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/: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}}/system/user/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/user/: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}}/system/user/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/user/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/: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}}/system/user/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/: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/system/user/: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}}/system/user/: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}}/system/user/: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}}/system/user/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/: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}}/system/user/: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}}/system/user/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/: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}}/system/user/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/user/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/: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/system/user/: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}}/system/user/: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}}/system/user/:id

http DELETE {{baseUrl}}/system/user/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/user/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/: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()

PUT 用户-更新

{{baseUrl}}/system/user

BODY json

{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user" {:content-type :json
                                                       :form-params {:deptId ""
                                                                     :email ""
                                                                     :nickName ""
                                                                     :userName ""
                                                                     :password ""
                                                                     :phonenumber ""
                                                                     :postIds []
                                                                     :roleIds []
                                                                     :status ""
                                                                     :sex ""
                                                                     :remark ""
                                                                     :postSort ""
                                                                     :userId ""}})

require "http/client"

url = "{{baseUrl}}/system/user"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user"),
    Content = new StringContent("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\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}}/system/user");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user"

	payload := strings.NewReader("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 221

{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\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  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user")
  .header("content-type", "application/json")
  .body("{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: '',
  userId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user',
  headers: {'content-type': 'application/json'},
  data: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: '',
    userId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deptId":"","email":"","nickName":"","userName":"","password":"","phonenumber":"","postIds":[],"roleIds":[],"status":"","sex":"","remark":"","postSort":"","userId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deptId": "",\n  "email": "",\n  "nickName": "",\n  "userName": "",\n  "password": "",\n  "phonenumber": "",\n  "postIds": [],\n  "roleIds": [],\n  "status": "",\n  "sex": "",\n  "remark": "",\n  "postSort": "",\n  "userId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: '',
  userId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user',
  headers: {'content-type': 'application/json'},
  body: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: '',
    userId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/user');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deptId: '',
  email: '',
  nickName: '',
  userName: '',
  password: '',
  phonenumber: '',
  postIds: [],
  roleIds: [],
  status: '',
  sex: '',
  remark: '',
  postSort: '',
  userId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user',
  headers: {'content-type': 'application/json'},
  data: {
    deptId: '',
    email: '',
    nickName: '',
    userName: '',
    password: '',
    phonenumber: '',
    postIds: [],
    roleIds: [],
    status: '',
    sex: '',
    remark: '',
    postSort: '',
    userId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deptId":"","email":"","nickName":"","userName":"","password":"","phonenumber":"","postIds":[],"roleIds":[],"status":"","sex":"","remark":"","postSort":"","userId":""}'
};

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 = @{ @"deptId": @"",
                              @"email": @"",
                              @"nickName": @"",
                              @"userName": @"",
                              @"password": @"",
                              @"phonenumber": @"",
                              @"postIds": @[  ],
                              @"roleIds": @[  ],
                              @"status": @"",
                              @"sex": @"",
                              @"remark": @"",
                              @"postSort": @"",
                              @"userId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'deptId' => '',
    'email' => '',
    'nickName' => '',
    'userName' => '',
    'password' => '',
    'phonenumber' => '',
    'postIds' => [
        
    ],
    'roleIds' => [
        
    ],
    'status' => '',
    'sex' => '',
    'remark' => '',
    'postSort' => '',
    'userId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/user', [
  'body' => '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deptId' => '',
  'email' => '',
  'nickName' => '',
  'userName' => '',
  'password' => '',
  'phonenumber' => '',
  'postIds' => [
    
  ],
  'roleIds' => [
    
  ],
  'status' => '',
  'sex' => '',
  'remark' => '',
  'postSort' => '',
  'userId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deptId' => '',
  'email' => '',
  'nickName' => '',
  'userName' => '',
  'password' => '',
  'phonenumber' => '',
  'postIds' => [
    
  ],
  'roleIds' => [
    
  ],
  'status' => '',
  'sex' => '',
  'remark' => '',
  'postSort' => '',
  'userId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/user", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user"

payload = {
    "deptId": "",
    "email": "",
    "nickName": "",
    "userName": "",
    "password": "",
    "phonenumber": "",
    "postIds": [],
    "roleIds": [],
    "status": "",
    "sex": "",
    "remark": "",
    "postSort": "",
    "userId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user"

payload <- "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\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.put('/baseUrl/system/user') do |req|
  req.body = "{\n  \"deptId\": \"\",\n  \"email\": \"\",\n  \"nickName\": \"\",\n  \"userName\": \"\",\n  \"password\": \"\",\n  \"phonenumber\": \"\",\n  \"postIds\": [],\n  \"roleIds\": [],\n  \"status\": \"\",\n  \"sex\": \"\",\n  \"remark\": \"\",\n  \"postSort\": \"\",\n  \"userId\": \"\"\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}}/system/user";

    let payload = json!({
        "deptId": "",
        "email": "",
        "nickName": "",
        "userName": "",
        "password": "",
        "phonenumber": "",
        "postIds": (),
        "roleIds": (),
        "status": "",
        "sex": "",
        "remark": "",
        "postSort": "",
        "userId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user \
  --header 'content-type: application/json' \
  --data '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}'

echo '{
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
}' |  \
  http PUT {{baseUrl}}/system/user \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "deptId": "",\n  "email": "",\n  "nickName": "",\n  "userName": "",\n  "password": "",\n  "phonenumber": "",\n  "postIds": [],\n  "roleIds": [],\n  "status": "",\n  "sex": "",\n  "remark": "",\n  "postSort": "",\n  "userId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deptId": "",
  "email": "",
  "nickName": "",
  "userName": "",
  "password": "",
  "phonenumber": "",
  "postIds": [],
  "roleIds": [],
  "status": "",
  "sex": "",
  "remark": "",
  "postSort": "",
  "userId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 用户-角色+岗位

{{baseUrl}}/system/user

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user")

require "http/client"

url = "{{baseUrl}}/system/user"

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}}/system/user"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/system/user HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/user');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/user'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/system/user'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/user');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/system/user'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/system/user');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/system/user') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/system/user

http GET {{baseUrl}}/system/user

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/user

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 用户-角色信息-更新

{{baseUrl}}/system/user/authRole

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/authRole");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user/authRole")

require "http/client"

url = "{{baseUrl}}/system/user/authRole"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user/authRole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/authRole");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/authRole"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user/authRole HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user/authRole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/authRole"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/authRole")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user/authRole")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user/authRole');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/system/user/authRole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/authRole';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/user/authRole',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/authRole")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/authRole',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/system/user/authRole'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/user/authRole');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'PUT', url: '{{baseUrl}}/system/user/authRole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/authRole';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/authRole"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user/authRole" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/authRole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/user/authRole');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/authRole');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/authRole');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/authRole' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/authRole' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/system/user/authRole")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/authRole"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/authRole"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/authRole")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/system/user/authRole') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/authRole";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user/authRole

http PUT {{baseUrl}}/system/user/authRole

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/system/user/authRole

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/authRole")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 用户-详情

{{baseUrl}}/system/user/:userId

QUERY PARAMS

userId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/:userId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user/:userId")

require "http/client"

url = "{{baseUrl}}/system/user/:userId"

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}}/system/user/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/:userId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/:userId"

	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/system/user/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/:userId"))
    .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}}/system/user/:userId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user/:userId")
  .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}}/system/user/:userId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/user/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/:userId';
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}}/system/user/:userId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/:userId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/:userId',
  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}}/system/user/:userId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/user/:userId');

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}}/system/user/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/:userId';
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}}/system/user/:userId"]
                                                       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}}/system/user/:userId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/:userId",
  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}}/system/user/:userId');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/:userId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/:userId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/:userId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/:userId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user/:userId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/:userId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/:userId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/:userId")

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/system/user/:userId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/:userId";

    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}}/system/user/:userId

http GET {{baseUrl}}/system/user/:userId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/user/:userId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/:userId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 用户-部门树

{{baseUrl}}/system/user/deptTree

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/deptTree");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/user/deptTree")

require "http/client"

url = "{{baseUrl}}/system/user/deptTree"

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}}/system/user/deptTree"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/user/deptTree");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/deptTree"

	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/system/user/deptTree HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/user/deptTree")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/deptTree"))
    .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}}/system/user/deptTree")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/user/deptTree")
  .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}}/system/user/deptTree');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/user/deptTree'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/deptTree';
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}}/system/user/deptTree',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/user/deptTree")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/deptTree',
  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}}/system/user/deptTree'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/user/deptTree');

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}}/system/user/deptTree'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/deptTree';
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}}/system/user/deptTree"]
                                                       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}}/system/user/deptTree" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/deptTree",
  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}}/system/user/deptTree');

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/deptTree');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/user/deptTree');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/deptTree' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/deptTree' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/user/deptTree")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/deptTree"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/deptTree"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/deptTree")

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/system/user/deptTree') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/user/deptTree";

    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}}/system/user/deptTree

http GET {{baseUrl}}/system/user/deptTree

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/user/deptTree

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/deptTree")! 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()

PUT 用户-重置密码

{{baseUrl}}/system/user/resetPwd

BODY json

{
  "userId": "",
  "password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/user/resetPwd");

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  \"userId\": \"\",\n  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/user/resetPwd" {:content-type :json
                                                                :form-params {:userId ""
                                                                              :password ""}})

require "http/client"

url = "{{baseUrl}}/system/user/resetPwd"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"userId\": \"\",\n  \"password\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/user/resetPwd"),
    Content = new StringContent("{\n  \"userId\": \"\",\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}}/system/user/resetPwd");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"userId\": \"\",\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/user/resetPwd"

	payload := strings.NewReader("{\n  \"userId\": \"\",\n  \"password\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/user/resetPwd HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "userId": "",
  "password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/user/resetPwd")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"userId\": \"\",\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/user/resetPwd"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"userId\": \"\",\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  \"userId\": \"\",\n  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/user/resetPwd")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/user/resetPwd")
  .header("content-type", "application/json")
  .body("{\n  \"userId\": \"\",\n  \"password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  userId: '',
  password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/user/resetPwd');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/resetPwd',
  headers: {'content-type': 'application/json'},
  data: {userId: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/user/resetPwd';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","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}}/system/user/resetPwd',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "userId": "",\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  \"userId\": \"\",\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/user/resetPwd")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/user/resetPwd',
  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({userId: '', password: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/user/resetPwd',
  headers: {'content-type': 'application/json'},
  body: {userId: '', 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('PUT', '{{baseUrl}}/system/user/resetPwd');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  userId: '',
  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: 'PUT',
  url: '{{baseUrl}}/system/user/resetPwd',
  headers: {'content-type': 'application/json'},
  data: {userId: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/user/resetPwd';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","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 = @{ @"userId": @"",
                              @"password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/user/resetPwd"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/user/resetPwd" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"userId\": \"\",\n  \"password\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/user/resetPwd",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'userId' => '',
    '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('PUT', '{{baseUrl}}/system/user/resetPwd', [
  'body' => '{
  "userId": "",
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/user/resetPwd');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'userId' => '',
  'password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'userId' => '',
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/user/resetPwd');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/user/resetPwd' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "password": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/user/resetPwd' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"userId\": \"\",\n  \"password\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/user/resetPwd", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/user/resetPwd"

payload = {
    "userId": "",
    "password": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/user/resetPwd"

payload <- "{\n  \"userId\": \"\",\n  \"password\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/user/resetPwd")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"userId\": \"\",\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.put('/baseUrl/system/user/resetPwd') do |req|
  req.body = "{\n  \"userId\": \"\",\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}}/system/user/resetPwd";

    let payload = json!({
        "userId": "",
        "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("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/user/resetPwd \
  --header 'content-type: application/json' \
  --data '{
  "userId": "",
  "password": ""
}'

echo '{
  "userId": "",
  "password": ""
}' |  \
  http PUT {{baseUrl}}/system/user/resetPwd \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "userId": "",\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/user/resetPwd

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "userId": "",
  "password": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/user/resetPwd")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 导出登录日志为xlsx文件

{{baseUrl}}/monitor/logininfor/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/logininfor/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/monitor/logininfor/export" {:content-type :json
                                                                      :form-params {:pageNum ""
                                                                                    :pageSize ""
                                                                                    :params ""
                                                                                    :orderByColumn ""
                                                                                    :isAsc ""
                                                                                    :ipaddr ""
                                                                                    :userName ""
                                                                                    :status ""}})

require "http/client"

url = "{{baseUrl}}/monitor/logininfor/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\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}}/monitor/logininfor/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/logininfor/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/logininfor/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/monitor/logininfor/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitor/logininfor/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/logininfor/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/monitor/logininfor/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/monitor/logininfor/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/logininfor/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/logininfor/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","ipaddr":"","userName":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/logininfor/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "ipaddr": "",\n  "userName": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/export")
  .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/monitor/logininfor/export',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/logininfor/export',
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/monitor/logininfor/export');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitor/logininfor/export',
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/logininfor/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","ipaddr":"","userName":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"ipaddr": @"",
                              @"userName": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/logininfor/export"]
                                                       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}}/monitor/logininfor/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/logininfor/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'ipaddr' => '',
    'userName' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/monitor/logininfor/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/logininfor/export');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'ipaddr' => '',
  'userName' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'ipaddr' => '',
  'userName' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/logininfor/export');
$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}}/monitor/logininfor/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/logininfor/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/monitor/logininfor/export", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/logininfor/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "ipaddr": "",
    "userName": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/logininfor/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/logininfor/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\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/monitor/logininfor/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/logininfor/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "ipaddr": "",
        "userName": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/monitor/logininfor/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/monitor/logininfor/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "ipaddr": "",\n  "userName": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/logininfor/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/logininfor/export")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 登录日志-列表

{{baseUrl}}/monitor/logininfor/list

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/logininfor/list" {:query-params {:pageNum ""
                                                                                  :pageSize ""}
                                                                   :content-type :json
                                                                   :form-params {:pageNum ""
                                                                                 :pageSize ""
                                                                                 :params ""
                                                                                 :orderByColumn ""
                                                                                 :isAsc ""
                                                                                 :ipaddr ""
                                                                                 :userName ""
                                                                                 :status ""}})

require "http/client"

url = "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/monitor/logininfor/list?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/logininfor/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","ipaddr":"","userName":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "ipaddr": "",\n  "userName": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/logininfor/list?pageNum=&pageSize=',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/logininfor/list',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/logininfor/list');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  ipaddr: '',
  userName: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/logininfor/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    ipaddr: '',
    userName: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","ipaddr":"","userName":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"ipaddr": @"",
                              @"userName": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/monitor/logininfor/list?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'ipaddr' => '',
    'userName' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/logininfor/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'ipaddr' => '',
  'userName' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'ipaddr' => '',
  'userName' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/logininfor/list');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/monitor/logininfor/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/monitor/logininfor/list?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/logininfor/list"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "ipaddr": "",
    "userName": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/logininfor/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\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.get('/baseUrl/monitor/logininfor/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/logininfor/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "ipaddr": "",
        "userName": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
}' |  \
  http GET '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "ipaddr": "",\n  "userName": "",\n  "status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "ipaddr": "",
  "userName": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/logininfor/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()

DELETE 登录日志-删除日志

{{baseUrl}}/monitor/logininfor/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/logininfor/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/logininfor/:id")

require "http/client"

url = "{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/logininfor/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/logininfor/: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/monitor/logininfor/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/logininfor/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/logininfor/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/: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/monitor/logininfor/: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}}/monitor/logininfor/: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}}/monitor/logininfor/: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}}/monitor/logininfor/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/: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}}/monitor/logininfor/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/logininfor/: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}}/monitor/logininfor/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/logininfor/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/logininfor/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/logininfor/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/logininfor/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/logininfor/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/logininfor/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/logininfor/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/logininfor/: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/monitor/logininfor/: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}}/monitor/logininfor/: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}}/monitor/logininfor/:id

http DELETE {{baseUrl}}/monitor/logininfor/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/logininfor/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/logininfor/: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()

DELETE 登录日志-清除全部日志

{{baseUrl}}/monitor/logininfor/clean

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/logininfor/clean");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/logininfor/clean")

require "http/client"

url = "{{baseUrl}}/monitor/logininfor/clean"

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}}/monitor/logininfor/clean"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/logininfor/clean");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/logininfor/clean"

	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/monitor/logininfor/clean HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/logininfor/clean")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/logininfor/clean"))
    .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}}/monitor/logininfor/clean")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/logininfor/clean")
  .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}}/monitor/logininfor/clean');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/logininfor/clean'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/logininfor/clean';
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}}/monitor/logininfor/clean',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/logininfor/clean")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/logininfor/clean',
  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}}/monitor/logininfor/clean'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/logininfor/clean');

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}}/monitor/logininfor/clean'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/logininfor/clean';
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}}/monitor/logininfor/clean"]
                                                       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}}/monitor/logininfor/clean" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/logininfor/clean",
  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}}/monitor/logininfor/clean');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/logininfor/clean');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/logininfor/clean');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/logininfor/clean' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/logininfor/clean' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/logininfor/clean")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/logininfor/clean"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/logininfor/clean"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/logininfor/clean")

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/monitor/logininfor/clean') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/logininfor/clean";

    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}}/monitor/logininfor/clean

http DELETE {{baseUrl}}/monitor/logininfor/clean

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/logininfor/clean

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/logininfor/clean")! 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()

PUT 修改代码生成信息

{{baseUrl}}/tool/gen

BODY json

{
  "tableId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen");

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  \"tableId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/tool/gen" {:content-type :json
                                                    :form-params {:tableId ""}})

require "http/client"

url = "{{baseUrl}}/tool/gen"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tableId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/tool/gen"),
    Content = new StringContent("{\n  \"tableId\": \"\"\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}}/tool/gen");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tableId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen"

	payload := strings.NewReader("{\n  \"tableId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/tool/gen HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "tableId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tool/gen")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tableId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"tableId\": \"\"\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  \"tableId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tool/gen")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/tool/gen")
  .header("content-type", "application/json")
  .body("{\n  \"tableId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  tableId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/tool/gen');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/tool/gen',
  headers: {'content-type': 'application/json'},
  data: {tableId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tableId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tool/gen',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tableId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tableId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen',
  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({tableId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/tool/gen',
  headers: {'content-type': 'application/json'},
  body: {tableId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/tool/gen');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tableId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/tool/gen',
  headers: {'content-type': 'application/json'},
  data: {tableId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tableId":""}'
};

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 = @{ @"tableId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tool/gen"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tool/gen" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tableId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'tableId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/tool/gen', [
  'body' => '{
  "tableId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tableId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tableId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tool/gen');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tableId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tableId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tableId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/tool/gen", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen"

payload = { "tableId": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen"

payload <- "{\n  \"tableId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"tableId\": \"\"\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.put('/baseUrl/tool/gen') do |req|
  req.body = "{\n  \"tableId\": \"\"\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}}/tool/gen";

    let payload = json!({"tableId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/tool/gen \
  --header 'content-type: application/json' \
  --data '{
  "tableId": ""
}'

echo '{
  "tableId": ""
}' |  \
  http PUT {{baseUrl}}/tool/gen \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "tableId": ""\n}' \
  --output-document \
  - {{baseUrl}}/tool/gen

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tableId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE 删除表数据

{{baseUrl}}/tool/gen/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tool/gen/:id")

require "http/client"

url = "{{baseUrl}}/tool/gen/: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}}/tool/gen/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/: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/tool/gen/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tool/gen/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/: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}}/tool/gen/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tool/gen/: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}}/tool/gen/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/tool/gen/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/: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}}/tool/gen/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/: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/tool/gen/: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}}/tool/gen/: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}}/tool/gen/: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}}/tool/gen/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/: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}}/tool/gen/: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}}/tool/gen/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/: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}}/tool/gen/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tool/gen/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/: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/tool/gen/: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}}/tool/gen/: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}}/tool/gen/:id

http DELETE {{baseUrl}}/tool/gen/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/tool/gen/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/: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()

GET 同步表

{{baseUrl}}/tool/gen/synchDb/:tableName

QUERY PARAMS

tableName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/synchDb/:tableName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/synchDb/:tableName")

require "http/client"

url = "{{baseUrl}}/tool/gen/synchDb/:tableName"

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}}/tool/gen/synchDb/:tableName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/synchDb/:tableName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/synchDb/:tableName"

	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/tool/gen/synchDb/:tableName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/synchDb/:tableName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/synchDb/:tableName"))
    .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}}/tool/gen/synchDb/:tableName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/synchDb/:tableName")
  .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}}/tool/gen/synchDb/:tableName');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tool/gen/synchDb/:tableName'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/synchDb/:tableName';
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}}/tool/gen/synchDb/:tableName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/synchDb/:tableName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/synchDb/:tableName',
  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}}/tool/gen/synchDb/:tableName'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tool/gen/synchDb/:tableName');

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}}/tool/gen/synchDb/:tableName'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/synchDb/:tableName';
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}}/tool/gen/synchDb/:tableName"]
                                                       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}}/tool/gen/synchDb/:tableName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/synchDb/:tableName",
  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}}/tool/gen/synchDb/:tableName');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/synchDb/:tableName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/synchDb/:tableName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/synchDb/:tableName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/synchDb/:tableName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/synchDb/:tableName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/synchDb/:tableName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/synchDb/:tableName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/synchDb/:tableName")

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/tool/gen/synchDb/:tableName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/synchDb/:tableName";

    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}}/tool/gen/synchDb/:tableName

http GET {{baseUrl}}/tool/gen/synchDb/:tableName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tool/gen/synchDb/:tableName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/synchDb/:tableName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 导入表

{{baseUrl}}/tool/gen/importTable

BODY json

{
  "tableNames": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/importTable");

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  \"tableNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tool/gen/importTable" {:content-type :json
                                                                 :form-params {:tableNames ""}})

require "http/client"

url = "{{baseUrl}}/tool/gen/importTable"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tableNames\": \"\"\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}}/tool/gen/importTable"),
    Content = new StringContent("{\n  \"tableNames\": \"\"\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}}/tool/gen/importTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tableNames\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/importTable"

	payload := strings.NewReader("{\n  \"tableNames\": \"\"\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/tool/gen/importTable HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "tableNames": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tool/gen/importTable")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tableNames\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/importTable"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tableNames\": \"\"\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  \"tableNames\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tool/gen/importTable")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tool/gen/importTable")
  .header("content-type", "application/json")
  .body("{\n  \"tableNames\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  tableNames: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tool/gen/importTable');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tool/gen/importTable',
  headers: {'content-type': 'application/json'},
  data: {tableNames: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/importTable';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tableNames":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tool/gen/importTable',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tableNames": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tableNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/importTable")
  .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/tool/gen/importTable',
  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({tableNames: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tool/gen/importTable',
  headers: {'content-type': 'application/json'},
  body: {tableNames: ''},
  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}}/tool/gen/importTable');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tableNames: ''
});

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}}/tool/gen/importTable',
  headers: {'content-type': 'application/json'},
  data: {tableNames: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/importTable';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tableNames":""}'
};

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 = @{ @"tableNames": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tool/gen/importTable"]
                                                       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}}/tool/gen/importTable" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tableNames\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/importTable",
  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([
    'tableNames' => ''
  ]),
  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}}/tool/gen/importTable', [
  'body' => '{
  "tableNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/importTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tableNames' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tableNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tool/gen/importTable');
$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}}/tool/gen/importTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tableNames": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/importTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tableNames": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tableNames\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tool/gen/importTable", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/importTable"

payload = { "tableNames": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/importTable"

payload <- "{\n  \"tableNames\": \"\"\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}}/tool/gen/importTable")

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  \"tableNames\": \"\"\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/tool/gen/importTable') do |req|
  req.body = "{\n  \"tableNames\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/importTable";

    let payload = json!({"tableNames": ""});

    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}}/tool/gen/importTable \
  --header 'content-type: application/json' \
  --data '{
  "tableNames": ""
}'

echo '{
  "tableNames": ""
}' |  \
  http POST {{baseUrl}}/tool/gen/importTable \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tableNames": ""\n}' \
  --output-document \
  - {{baseUrl}}/tool/gen/importTable

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tableNames": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/importTable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 数据表列表

{{baseUrl}}/tool/gen/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/list" {:query-params {:pageNum ""
                                                                        :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/tool/gen/list?pageNum=&pageSize="

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}}/tool/gen/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/list?pageNum=&pageSize="

	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/tool/gen/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/list?pageNum=&pageSize="))
    .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}}/tool/gen/list?pageNum=&pageSize=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/list?pageNum=&pageSize=")
  .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}}/tool/gen/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tool/gen/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/list?pageNum=&pageSize=';
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}}/tool/gen/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/list?pageNum=&pageSize=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/list?pageNum=&pageSize=',
  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}}/tool/gen/list',
  qs: {pageNum: '', pageSize: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tool/gen/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/tool/gen/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/list?pageNum=&pageSize=';
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}}/tool/gen/list?pageNum=&pageSize="]
                                                       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}}/tool/gen/list?pageNum=&pageSize=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/list?pageNum=&pageSize=",
  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}}/tool/gen/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/list?pageNum=&pageSize=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/list?pageNum=&pageSize=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/list"

querystring = {"pageNum":"","pageSize":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/list?pageNum=&pageSize=")

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/tool/gen/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/tool/gen/list?pageNum=&pageSize='

http GET '{{baseUrl}}/tool/gen/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/tool/gen/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 查看代码

{{baseUrl}}/tool/gen/preview/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/preview/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/preview/:id")

require "http/client"

url = "{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/preview/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/preview/: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/tool/gen/preview/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/preview/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tool/gen/preview/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/preview/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/preview/: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}}/tool/gen/preview/: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}}/tool/gen/preview/: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}}/tool/gen/preview/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/: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}}/tool/gen/preview/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/preview/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/preview/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/preview/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/preview/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/preview/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/preview/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/preview/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/preview/: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/tool/gen/preview/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/preview/: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}}/tool/gen/preview/:id

http GET {{baseUrl}}/tool/gen/preview/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tool/gen/preview/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/preview/: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()

GET 查询数据库列表

{{baseUrl}}/tool/gen/db/list

QUERY PARAMS

pageNum

pageSize

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/db/list" {:query-params {:pageNum ""
                                                                           :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize="

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}}/tool/gen/db/list?pageNum=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize="

	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/tool/gen/db/list?pageNum=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize="))
    .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}}/tool/gen/db/list?pageNum=&pageSize=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=")
  .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}}/tool/gen/db/list?pageNum=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tool/gen/db/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=';
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}}/tool/gen/db/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/db/list?pageNum=&pageSize=',
  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}}/tool/gen/db/list',
  qs: {pageNum: '', pageSize: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tool/gen/db/list');

req.query({
  pageNum: '',
  pageSize: ''
});

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}}/tool/gen/db/list',
  params: {pageNum: '', pageSize: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=';
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}}/tool/gen/db/list?pageNum=&pageSize="]
                                                       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}}/tool/gen/db/list?pageNum=&pageSize=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=",
  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}}/tool/gen/db/list?pageNum=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/db/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/db/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/db/list?pageNum=&pageSize=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/db/list"

querystring = {"pageNum":"","pageSize":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/db/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=")

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/tool/gen/db/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/db/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    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}}/tool/gen/db/list?pageNum=&pageSize='

http GET '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/db/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 查询表详细信息

{{baseUrl}}/tool/gen/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/:id")

require "http/client"

url = "{{baseUrl}}/tool/gen/: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}}/tool/gen/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/: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/tool/gen/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/: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}}/tool/gen/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/: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}}/tool/gen/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tool/gen/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/: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}}/tool/gen/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/: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}}/tool/gen/: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}}/tool/gen/: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}}/tool/gen/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/: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}}/tool/gen/: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}}/tool/gen/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/: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}}/tool/gen/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/: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/tool/gen/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/: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}}/tool/gen/:id

http GET {{baseUrl}}/tool/gen/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tool/gen/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/: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()

GET 生成代码

{{baseUrl}}/tool/gen/batchGenCode/zip

QUERY PARAMS

tableNames

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tool/gen/batchGenCode/zip" {:query-params {:tableNames ""}})

require "http/client"

url = "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames="

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}}/tool/gen/batchGenCode/zip?tableNames="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames="

	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/tool/gen/batchGenCode/zip?tableNames= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames="))
    .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}}/tool/gen/batchGenCode/zip?tableNames=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=")
  .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}}/tool/gen/batchGenCode/zip?tableNames=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tool/gen/batchGenCode/zip',
  params: {tableNames: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=';
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}}/tool/gen/batchGenCode/zip?tableNames=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tool/gen/batchGenCode/zip?tableNames=',
  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}}/tool/gen/batchGenCode/zip',
  qs: {tableNames: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tool/gen/batchGenCode/zip');

req.query({
  tableNames: ''
});

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}}/tool/gen/batchGenCode/zip',
  params: {tableNames: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=';
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}}/tool/gen/batchGenCode/zip?tableNames="]
                                                       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}}/tool/gen/batchGenCode/zip?tableNames=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=",
  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}}/tool/gen/batchGenCode/zip?tableNames=');

echo $response->getBody();

setUrl('{{baseUrl}}/tool/gen/batchGenCode/zip');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'tableNames' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tool/gen/batchGenCode/zip');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'tableNames' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tool/gen/batchGenCode/zip?tableNames=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tool/gen/batchGenCode/zip"

querystring = {"tableNames":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tool/gen/batchGenCode/zip"

queryString <- list(tableNames = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=")

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/tool/gen/batchGenCode/zip') do |req|
  req.params['tableNames'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tool/gen/batchGenCode/zip";

    let querystring = [
        ("tableNames", ""),
    ];

    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}}/tool/gen/batchGenCode/zip?tableNames='

http GET '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tool/gen/batchGenCode/zip?tableNames=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 在线用户-列表 (GET)

{{baseUrl}}/monitor/online/list

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/online/list");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/online/list" {:content-type :json
                                                               :form-params {:pageNum ""
                                                                             :pageSize ""
                                                                             :ipaddr ""
                                                                             :userName ""}})

require "http/client"

url = "{{baseUrl}}/monitor/online/list"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/monitor/online/list"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/online/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/online/list"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/monitor/online/list HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/online/list")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/online/list"))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/monitor/online/list")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/online/list")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  ipaddr: '',
  userName: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/monitor/online/list');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/online/list',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', ipaddr: '', userName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/online/list';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","ipaddr":"","userName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/monitor/online/list',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "ipaddr": "",\n  "userName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitor/online/list")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/online/list',
  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({pageNum: '', pageSize: '', ipaddr: '', userName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/online/list',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', ipaddr: '', userName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/online/list');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  ipaddr: '',
  userName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/online/list',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', ipaddr: '', userName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/online/list';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","ipaddr":"","userName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"ipaddr": @"",
                              @"userName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/monitor/online/list"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/monitor/online/list" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/online/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'ipaddr' => '',
    'userName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/monitor/online/list', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/online/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'ipaddr' => '',
  'userName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'ipaddr' => '',
  'userName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitor/online/list');
$request->setRequestMethod('GET');
$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}}/monitor/online/list' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/online/list' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/monitor/online/list", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/online/list"

payload = {
    "pageNum": "",
    "pageSize": "",
    "ipaddr": "",
    "userName": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/online/list"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/online/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\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.get('/baseUrl/monitor/online/list') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"ipaddr\": \"\",\n  \"userName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/online/list";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "ipaddr": "",
        "userName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/monitor/online/list \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
}' |  \
  http GET {{baseUrl}}/monitor/online/list \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "ipaddr": "",\n  "userName": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitor/online/list

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "ipaddr": "",
  "userName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/online/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()

DELETE 在线用户-强退

{{baseUrl}}/monitor/online/:token

QUERY PARAMS

token

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/online/:token");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/online/:token")

require "http/client"

url = "{{baseUrl}}/monitor/online/:token"

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}}/monitor/online/:token"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/online/:token");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/online/:token"

	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/monitor/online/:token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/online/:token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/online/:token"))
    .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}}/monitor/online/:token")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/online/: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('DELETE', '{{baseUrl}}/monitor/online/:token');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/monitor/online/:token'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/online/:token';
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}}/monitor/online/:token',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/online/:token")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/online/: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: 'DELETE', url: '{{baseUrl}}/monitor/online/:token'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/online/: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: 'DELETE', url: '{{baseUrl}}/monitor/online/:token'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/online/:token';
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}}/monitor/online/:token"]
                                                       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}}/monitor/online/:token" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/online/:token",
  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}}/monitor/online/:token');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/online/:token');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/online/:token');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/online/:token' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/online/:token' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/online/:token")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/online/:token"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/online/:token"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/online/:token")

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/monitor/online/:token') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/online/:token";

    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}}/monitor/online/:token

http DELETE {{baseUrl}}/monitor/online/:token

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/online/:token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/online/:token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 在线用户-列表

{{baseUrl}}/monitor/server

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/server");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/server")

require "http/client"

url = "{{baseUrl}}/monitor/server"

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}}/monitor/server"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/server");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/server"

	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/monitor/server HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/server")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/server"))
    .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}}/monitor/server")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/server")
  .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}}/monitor/server');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/server';
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}}/monitor/server',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/server")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/server',
  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}}/monitor/server'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/server');

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}}/monitor/server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/server';
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}}/monitor/server"]
                                                       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}}/monitor/server" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/server",
  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}}/monitor/server');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/server');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/server');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/server' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/server' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/server")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/server"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/server"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/server")

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/monitor/server') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/server";

    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}}/monitor/server

http GET {{baseUrl}}/monitor/server

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/server

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/server")! 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()

DELETE 清理全部

{{baseUrl}}/monitor/cache/clearCacheAll

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/clearCacheAll");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/cache/clearCacheAll")

require "http/client"

url = "{{baseUrl}}/monitor/cache/clearCacheAll"

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}}/monitor/cache/clearCacheAll"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/clearCacheAll");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/clearCacheAll"

	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/monitor/cache/clearCacheAll HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/cache/clearCacheAll")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/clearCacheAll"))
    .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}}/monitor/cache/clearCacheAll")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/cache/clearCacheAll")
  .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}}/monitor/cache/clearCacheAll');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/monitor/cache/clearCacheAll'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/clearCacheAll';
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}}/monitor/cache/clearCacheAll',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/clearCacheAll")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/clearCacheAll',
  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}}/monitor/cache/clearCacheAll'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/cache/clearCacheAll');

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}}/monitor/cache/clearCacheAll'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/clearCacheAll';
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}}/monitor/cache/clearCacheAll"]
                                                       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}}/monitor/cache/clearCacheAll" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/clearCacheAll",
  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}}/monitor/cache/clearCacheAll');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/clearCacheAll');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/clearCacheAll');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/clearCacheAll' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/clearCacheAll' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/cache/clearCacheAll")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/clearCacheAll"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/clearCacheAll"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/clearCacheAll")

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/monitor/cache/clearCacheAll') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/clearCacheAll";

    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}}/monitor/cache/clearCacheAll

http DELETE {{baseUrl}}/monitor/cache/clearCacheAll

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/cache/clearCacheAll

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/clearCacheAll")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE 清理缓存名称

{{baseUrl}}/monitor/cache/clearCacheName/:cacheName

QUERY PARAMS

cacheName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")

require "http/client"

url = "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName"

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}}/monitor/cache/clearCacheName/:cacheName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/clearCacheName/:cacheName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName"

	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/monitor/cache/clearCacheName/:cacheName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/clearCacheName/:cacheName"))
    .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}}/monitor/cache/clearCacheName/:cacheName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")
  .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}}/monitor/cache/clearCacheName/:cacheName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName';
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}}/monitor/cache/clearCacheName/:cacheName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/clearCacheName/:cacheName',
  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}}/monitor/cache/clearCacheName/:cacheName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName');

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}}/monitor/cache/clearCacheName/:cacheName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName';
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}}/monitor/cache/clearCacheName/:cacheName"]
                                                       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}}/monitor/cache/clearCacheName/:cacheName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName",
  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}}/monitor/cache/clearCacheName/:cacheName');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/clearCacheName/:cacheName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/clearCacheName/:cacheName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/clearCacheName/:cacheName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/cache/clearCacheName/:cacheName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")

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/monitor/cache/clearCacheName/:cacheName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName";

    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}}/monitor/cache/clearCacheName/:cacheName

http DELETE {{baseUrl}}/monitor/cache/clearCacheName/:cacheName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/cache/clearCacheName/:cacheName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/clearCacheName/:cacheName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE 清理缓存键名

{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey

QUERY PARAMS

cacheKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")

require "http/client"

url = "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey"

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}}/monitor/cache/clearCacheKey/:cacheKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey"

	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/monitor/cache/clearCacheKey/:cacheKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey"))
    .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}}/monitor/cache/clearCacheKey/:cacheKey")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")
  .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}}/monitor/cache/clearCacheKey/:cacheKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey';
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}}/monitor/cache/clearCacheKey/:cacheKey',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/clearCacheKey/:cacheKey',
  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}}/monitor/cache/clearCacheKey/:cacheKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey');

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}}/monitor/cache/clearCacheKey/:cacheKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey';
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}}/monitor/cache/clearCacheKey/:cacheKey"]
                                                       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}}/monitor/cache/clearCacheKey/:cacheKey" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey",
  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}}/monitor/cache/clearCacheKey/:cacheKey');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/monitor/cache/clearCacheKey/:cacheKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")

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/monitor/cache/clearCacheKey/:cacheKey') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey";

    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}}/monitor/cache/clearCacheKey/:cacheKey

http DELETE {{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/clearCacheKey/:cacheKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 缓存内容

{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")

require "http/client"

url = "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey"

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}}/monitor/cache/getValue/:cacheName/:cacheKey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey"

	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/monitor/cache/getValue/:cacheName/:cacheKey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey"))
    .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}}/monitor/cache/getValue/:cacheName/:cacheKey")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")
  .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}}/monitor/cache/getValue/:cacheName/:cacheKey');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey';
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}}/monitor/cache/getValue/:cacheName/:cacheKey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/getValue/:cacheName/:cacheKey',
  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}}/monitor/cache/getValue/:cacheName/:cacheKey'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey');

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}}/monitor/cache/getValue/:cacheName/:cacheKey'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey';
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}}/monitor/cache/getValue/:cacheName/:cacheKey"]
                                                       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}}/monitor/cache/getValue/:cacheName/:cacheKey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey",
  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}}/monitor/cache/getValue/:cacheName/:cacheKey');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/cache/getValue/:cacheName/:cacheKey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")

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/monitor/cache/getValue/:cacheName/:cacheKey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey";

    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}}/monitor/cache/getValue/:cacheName/:cacheKey

http GET {{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/getValue/:cacheName/:cacheKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 缓存列表

{{baseUrl}}/monitor/cache/getNames

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/getNames");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/cache/getNames")

require "http/client"

url = "{{baseUrl}}/monitor/cache/getNames"

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}}/monitor/cache/getNames"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/getNames");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/getNames"

	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/monitor/cache/getNames HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/cache/getNames")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/getNames"))
    .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}}/monitor/cache/getNames")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/cache/getNames")
  .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}}/monitor/cache/getNames');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/cache/getNames'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/getNames';
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}}/monitor/cache/getNames',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/getNames")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/getNames',
  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}}/monitor/cache/getNames'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/cache/getNames');

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}}/monitor/cache/getNames'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/getNames';
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}}/monitor/cache/getNames"]
                                                       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}}/monitor/cache/getNames" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/getNames",
  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}}/monitor/cache/getNames');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/getNames');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/getNames');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/getNames' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/getNames' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/cache/getNames")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/getNames"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/getNames"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/getNames")

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/monitor/cache/getNames') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/getNames";

    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}}/monitor/cache/getNames

http GET {{baseUrl}}/monitor/cache/getNames

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/cache/getNames

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/getNames")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 缓存监控信息

{{baseUrl}}/monitor/cache

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/cache")

require "http/client"

url = "{{baseUrl}}/monitor/cache"

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}}/monitor/cache"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache"

	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/monitor/cache HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/cache")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache"))
    .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}}/monitor/cache")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/cache")
  .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}}/monitor/cache');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/cache'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache';
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}}/monitor/cache',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache',
  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}}/monitor/cache'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/monitor/cache');

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}}/monitor/cache'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache';
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}}/monitor/cache"]
                                                       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}}/monitor/cache" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache",
  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}}/monitor/cache');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/cache")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache")

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/monitor/cache') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache";

    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}}/monitor/cache

http GET {{baseUrl}}/monitor/cache

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/cache

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 键名列表

{{baseUrl}}/monitor/cache/getKeys/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitor/cache/getKeys/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/monitor/cache/getKeys/:id")

require "http/client"

url = "{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/monitor/cache/getKeys/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/monitor/cache/getKeys/: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/monitor/cache/getKeys/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/monitor/cache/getKeys/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/monitor/cache/getKeys/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/monitor/cache/getKeys/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/monitor/cache/getKeys/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/monitor/cache/getKeys/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/monitor/cache/getKeys/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitor/cache/getKeys/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/monitor/cache/getKeys/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/monitor/cache/getKeys/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitor/cache/getKeys/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/monitor/cache/getKeys/: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/monitor/cache/getKeys/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/monitor/cache/getKeys/: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}}/monitor/cache/getKeys/:id

http GET {{baseUrl}}/monitor/cache/getKeys/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/monitor/cache/getKeys/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/monitor/cache/getKeys/: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()

PUT 菜单管理-修改

{{baseUrl}}/system/menu

BODY json

{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu");

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  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/menu" {:content-type :json
                                                       :form-params {:menuName ""
                                                                     :orderNum ""
                                                                     :parentId ""
                                                                     :path ""
                                                                     :query ""
                                                                     :component ""
                                                                     :icon ""
                                                                     :menuType ""
                                                                     :isCache ""
                                                                     :isFrame ""
                                                                     :status ""
                                                                     :visible ""
                                                                     :perms ""
                                                                     :menuId ""}})

require "http/client"

url = "{{baseUrl}}/system/menu"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/menu"),
    Content = new StringContent("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\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}}/system/menu");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu"

	payload := strings.NewReader("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/menu HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 234

{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/menu")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\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  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/menu")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/menu")
  .header("content-type", "application/json")
  .body("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: '',
  menuId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/menu');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/menu',
  headers: {'content-type': 'application/json'},
  data: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: '',
    menuId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"menuName":"","orderNum":"","parentId":"","path":"","query":"","component":"","icon":"","menuType":"","isCache":"","isFrame":"","status":"","visible":"","perms":"","menuId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/menu',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "menuName": "",\n  "orderNum": "",\n  "parentId": "",\n  "path": "",\n  "query": "",\n  "component": "",\n  "icon": "",\n  "menuType": "",\n  "isCache": "",\n  "isFrame": "",\n  "status": "",\n  "visible": "",\n  "perms": "",\n  "menuId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/menu")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu',
  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({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: '',
  menuId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/menu',
  headers: {'content-type': 'application/json'},
  body: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: '',
    menuId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/menu');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: '',
  menuId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/menu',
  headers: {'content-type': 'application/json'},
  data: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: '',
    menuId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"menuName":"","orderNum":"","parentId":"","path":"","query":"","component":"","icon":"","menuType":"","isCache":"","isFrame":"","status":"","visible":"","perms":"","menuId":""}'
};

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 = @{ @"menuName": @"",
                              @"orderNum": @"",
                              @"parentId": @"",
                              @"path": @"",
                              @"query": @"",
                              @"component": @"",
                              @"icon": @"",
                              @"menuType": @"",
                              @"isCache": @"",
                              @"isFrame": @"",
                              @"status": @"",
                              @"visible": @"",
                              @"perms": @"",
                              @"menuId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/menu"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/menu" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'menuName' => '',
    'orderNum' => '',
    'parentId' => '',
    'path' => '',
    'query' => '',
    'component' => '',
    'icon' => '',
    'menuType' => '',
    'isCache' => '',
    'isFrame' => '',
    'status' => '',
    'visible' => '',
    'perms' => '',
    'menuId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/menu', [
  'body' => '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'menuName' => '',
  'orderNum' => '',
  'parentId' => '',
  'path' => '',
  'query' => '',
  'component' => '',
  'icon' => '',
  'menuType' => '',
  'isCache' => '',
  'isFrame' => '',
  'status' => '',
  'visible' => '',
  'perms' => '',
  'menuId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'menuName' => '',
  'orderNum' => '',
  'parentId' => '',
  'path' => '',
  'query' => '',
  'component' => '',
  'icon' => '',
  'menuType' => '',
  'isCache' => '',
  'isFrame' => '',
  'status' => '',
  'visible' => '',
  'perms' => '',
  'menuId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/menu');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/menu", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu"

payload = {
    "menuName": "",
    "orderNum": "",
    "parentId": "",
    "path": "",
    "query": "",
    "component": "",
    "icon": "",
    "menuType": "",
    "isCache": "",
    "isFrame": "",
    "status": "",
    "visible": "",
    "perms": "",
    "menuId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu"

payload <- "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\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.put('/baseUrl/system/menu') do |req|
  req.body = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\",\n  \"menuId\": \"\"\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}}/system/menu";

    let payload = json!({
        "menuName": "",
        "orderNum": "",
        "parentId": "",
        "path": "",
        "query": "",
        "component": "",
        "icon": "",
        "menuType": "",
        "isCache": "",
        "isFrame": "",
        "status": "",
        "visible": "",
        "perms": "",
        "menuId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/menu \
  --header 'content-type: application/json' \
  --data '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}'

echo '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
}' |  \
  http PUT {{baseUrl}}/system/menu \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "menuName": "",\n  "orderNum": "",\n  "parentId": "",\n  "path": "",\n  "query": "",\n  "component": "",\n  "icon": "",\n  "menuType": "",\n  "isCache": "",\n  "isFrame": "",\n  "status": "",\n  "visible": "",\n  "perms": "",\n  "menuId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/menu

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": "",
  "menuId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 菜单管理-列表

{{baseUrl}}/system/menu/list

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu/list");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/menu/list")

require "http/client"

url = "{{baseUrl}}/system/menu/list"

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}}/system/menu/list"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/menu/list");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu/list"

	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/system/menu/list HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/menu/list")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu/list"))
    .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}}/system/menu/list")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/menu/list")
  .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}}/system/menu/list');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/menu/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu/list';
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}}/system/menu/list',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/menu/list")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu/list',
  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}}/system/menu/list'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/menu/list');

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}}/system/menu/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu/list';
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}}/system/menu/list"]
                                                       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}}/system/menu/list" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu/list",
  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}}/system/menu/list');

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu/list');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/menu/list');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu/list' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu/list' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/menu/list")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu/list"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu/list"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu/list")

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/system/menu/list') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu/list";

    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}}/system/menu/list

http GET {{baseUrl}}/system/menu/list

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/menu/list

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 菜单管理-创建

{{baseUrl}}/system/menu

BODY json

{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu");

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  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/menu" {:content-type :json
                                                        :form-params {:menuName ""
                                                                      :orderNum ""
                                                                      :parentId ""
                                                                      :path ""
                                                                      :query ""
                                                                      :component ""
                                                                      :icon ""
                                                                      :menuType ""
                                                                      :isCache ""
                                                                      :isFrame ""
                                                                      :status ""
                                                                      :visible ""
                                                                      :perms ""}})

require "http/client"

url = "{{baseUrl}}/system/menu"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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}}/system/menu"),
    Content = new StringContent("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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}}/system/menu");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu"

	payload := strings.NewReader("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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/system/menu HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 218

{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/menu")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/menu")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/menu")
  .header("content-type", "application/json")
  .body("{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/menu');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/menu',
  headers: {'content-type': 'application/json'},
  data: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"menuName":"","orderNum":"","parentId":"","path":"","query":"","component":"","icon":"","menuType":"","isCache":"","isFrame":"","status":"","visible":"","perms":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/menu',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "menuName": "",\n  "orderNum": "",\n  "parentId": "",\n  "path": "",\n  "query": "",\n  "component": "",\n  "icon": "",\n  "menuType": "",\n  "isCache": "",\n  "isFrame": "",\n  "status": "",\n  "visible": "",\n  "perms": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/menu")
  .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/system/menu',
  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({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/menu',
  headers: {'content-type': 'application/json'},
  body: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: ''
  },
  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}}/system/menu');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  menuName: '',
  orderNum: '',
  parentId: '',
  path: '',
  query: '',
  component: '',
  icon: '',
  menuType: '',
  isCache: '',
  isFrame: '',
  status: '',
  visible: '',
  perms: ''
});

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}}/system/menu',
  headers: {'content-type': 'application/json'},
  data: {
    menuName: '',
    orderNum: '',
    parentId: '',
    path: '',
    query: '',
    component: '',
    icon: '',
    menuType: '',
    isCache: '',
    isFrame: '',
    status: '',
    visible: '',
    perms: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"menuName":"","orderNum":"","parentId":"","path":"","query":"","component":"","icon":"","menuType":"","isCache":"","isFrame":"","status":"","visible":"","perms":""}'
};

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 = @{ @"menuName": @"",
                              @"orderNum": @"",
                              @"parentId": @"",
                              @"path": @"",
                              @"query": @"",
                              @"component": @"",
                              @"icon": @"",
                              @"menuType": @"",
                              @"isCache": @"",
                              @"isFrame": @"",
                              @"status": @"",
                              @"visible": @"",
                              @"perms": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/menu"]
                                                       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}}/system/menu" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu",
  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([
    'menuName' => '',
    'orderNum' => '',
    'parentId' => '',
    'path' => '',
    'query' => '',
    'component' => '',
    'icon' => '',
    'menuType' => '',
    'isCache' => '',
    'isFrame' => '',
    'status' => '',
    'visible' => '',
    'perms' => ''
  ]),
  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}}/system/menu', [
  'body' => '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'menuName' => '',
  'orderNum' => '',
  'parentId' => '',
  'path' => '',
  'query' => '',
  'component' => '',
  'icon' => '',
  'menuType' => '',
  'isCache' => '',
  'isFrame' => '',
  'status' => '',
  'visible' => '',
  'perms' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'menuName' => '',
  'orderNum' => '',
  'parentId' => '',
  'path' => '',
  'query' => '',
  'component' => '',
  'icon' => '',
  'menuType' => '',
  'isCache' => '',
  'isFrame' => '',
  'status' => '',
  'visible' => '',
  'perms' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/menu');
$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}}/system/menu' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/menu", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu"

payload = {
    "menuName": "",
    "orderNum": "",
    "parentId": "",
    "path": "",
    "query": "",
    "component": "",
    "icon": "",
    "menuType": "",
    "isCache": "",
    "isFrame": "",
    "status": "",
    "visible": "",
    "perms": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu"

payload <- "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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}}/system/menu")

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  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\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/system/menu') do |req|
  req.body = "{\n  \"menuName\": \"\",\n  \"orderNum\": \"\",\n  \"parentId\": \"\",\n  \"path\": \"\",\n  \"query\": \"\",\n  \"component\": \"\",\n  \"icon\": \"\",\n  \"menuType\": \"\",\n  \"isCache\": \"\",\n  \"isFrame\": \"\",\n  \"status\": \"\",\n  \"visible\": \"\",\n  \"perms\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu";

    let payload = json!({
        "menuName": "",
        "orderNum": "",
        "parentId": "",
        "path": "",
        "query": "",
        "component": "",
        "icon": "",
        "menuType": "",
        "isCache": "",
        "isFrame": "",
        "status": "",
        "visible": "",
        "perms": ""
    });

    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}}/system/menu \
  --header 'content-type: application/json' \
  --data '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}'

echo '{
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
}' |  \
  http POST {{baseUrl}}/system/menu \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "menuName": "",\n  "orderNum": "",\n  "parentId": "",\n  "path": "",\n  "query": "",\n  "component": "",\n  "icon": "",\n  "menuType": "",\n  "isCache": "",\n  "isFrame": "",\n  "status": "",\n  "visible": "",\n  "perms": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/menu

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "menuName": "",
  "orderNum": "",
  "parentId": "",
  "path": "",
  "query": "",
  "component": "",
  "icon": "",
  "menuType": "",
  "isCache": "",
  "isFrame": "",
  "status": "",
  "visible": "",
  "perms": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu")! 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()

DELETE 菜单管理-删除

{{baseUrl}}/system/menu/:menuId

QUERY PARAMS

menuId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu/:menuId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/menu/:menuId")

require "http/client"

url = "{{baseUrl}}/system/menu/:menuId"

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}}/system/menu/:menuId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/menu/:menuId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu/:menuId"

	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/system/menu/:menuId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/menu/:menuId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu/:menuId"))
    .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}}/system/menu/:menuId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/menu/:menuId")
  .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}}/system/menu/:menuId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/menu/:menuId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu/:menuId';
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}}/system/menu/:menuId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/menu/:menuId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu/:menuId',
  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}}/system/menu/:menuId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/system/menu/:menuId');

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}}/system/menu/:menuId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu/:menuId';
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}}/system/menu/:menuId"]
                                                       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}}/system/menu/:menuId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu/:menuId",
  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}}/system/menu/:menuId');

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu/:menuId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/menu/:menuId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu/:menuId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu/:menuId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/menu/:menuId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu/:menuId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu/:menuId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu/:menuId")

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/system/menu/:menuId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu/:menuId";

    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}}/system/menu/:menuId

http DELETE {{baseUrl}}/system/menu/:menuId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/menu/:menuId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu/:menuId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 菜单管理-树表

{{baseUrl}}/system/menu/treeselect

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu/treeselect");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/menu/treeselect")

require "http/client"

url = "{{baseUrl}}/system/menu/treeselect"

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}}/system/menu/treeselect"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/menu/treeselect");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu/treeselect"

	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/system/menu/treeselect HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/menu/treeselect")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu/treeselect"))
    .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}}/system/menu/treeselect")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/menu/treeselect")
  .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}}/system/menu/treeselect');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/menu/treeselect'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu/treeselect';
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}}/system/menu/treeselect',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/menu/treeselect")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu/treeselect',
  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}}/system/menu/treeselect'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/menu/treeselect');

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}}/system/menu/treeselect'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu/treeselect';
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}}/system/menu/treeselect"]
                                                       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}}/system/menu/treeselect" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu/treeselect",
  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}}/system/menu/treeselect');

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu/treeselect');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/menu/treeselect');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu/treeselect' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu/treeselect' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/menu/treeselect")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu/treeselect"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu/treeselect"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu/treeselect")

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/system/menu/treeselect') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu/treeselect";

    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}}/system/menu/treeselect

http GET {{baseUrl}}/system/menu/treeselect

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/menu/treeselect

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu/treeselect")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 菜单管理-角色-树表

{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId

QUERY PARAMS

menuId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")

require "http/client"

url = "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId"

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}}/system/menu/roleMenuTreeselect/:menuId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId"

	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/system/menu/roleMenuTreeselect/:menuId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId"))
    .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}}/system/menu/roleMenuTreeselect/:menuId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")
  .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}}/system/menu/roleMenuTreeselect/:menuId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId';
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}}/system/menu/roleMenuTreeselect/:menuId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu/roleMenuTreeselect/:menuId',
  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}}/system/menu/roleMenuTreeselect/:menuId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId');

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}}/system/menu/roleMenuTreeselect/:menuId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId';
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}}/system/menu/roleMenuTreeselect/:menuId"]
                                                       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}}/system/menu/roleMenuTreeselect/:menuId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId",
  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}}/system/menu/roleMenuTreeselect/:menuId');

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/menu/roleMenuTreeselect/:menuId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")

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/system/menu/roleMenuTreeselect/:menuId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId";

    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}}/system/menu/roleMenuTreeselect/:menuId

http GET {{baseUrl}}/system/menu/roleMenuTreeselect/:menuId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/menu/roleMenuTreeselect/:menuId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu/roleMenuTreeselect/:menuId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 菜单管理-详情

{{baseUrl}}/system/menu/:menuId

QUERY PARAMS

menuId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/menu/:menuId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/menu/:menuId")

require "http/client"

url = "{{baseUrl}}/system/menu/:menuId"

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}}/system/menu/:menuId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/menu/:menuId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/menu/:menuId"

	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/system/menu/:menuId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/menu/:menuId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/menu/:menuId"))
    .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}}/system/menu/:menuId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/menu/:menuId")
  .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}}/system/menu/:menuId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/menu/:menuId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/menu/:menuId';
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}}/system/menu/:menuId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/menu/:menuId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/menu/:menuId',
  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}}/system/menu/:menuId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/menu/:menuId');

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}}/system/menu/:menuId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/menu/:menuId';
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}}/system/menu/:menuId"]
                                                       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}}/system/menu/:menuId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/menu/:menuId",
  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}}/system/menu/:menuId');

echo $response->getBody();

setUrl('{{baseUrl}}/system/menu/:menuId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/menu/:menuId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/menu/:menuId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/menu/:menuId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/menu/:menuId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/menu/:menuId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/menu/:menuId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/menu/:menuId")

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/system/menu/:menuId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/menu/:menuId";

    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}}/system/menu/:menuId

http GET {{baseUrl}}/system/menu/:menuId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/menu/:menuId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/menu/:menuId")! 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()

DELETE RoleController_remove

{{baseUrl}}/system/role/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/role/:id")

require "http/client"

url = "{{baseUrl}}/system/role/: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}}/system/role/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/role/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/: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/system/role/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/role/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/: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}}/system/role/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/role/: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}}/system/role/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/role/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/: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}}/system/role/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/role/: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/system/role/: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}}/system/role/: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}}/system/role/: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}}/system/role/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/: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}}/system/role/: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}}/system/role/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/: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}}/system/role/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/role/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/role/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/: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/system/role/: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}}/system/role/: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}}/system/role/:id

http DELETE {{baseUrl}}/system/role/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/role/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/: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()

POST 导出角色管理xlsx文件

{{baseUrl}}/system/role/export

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/export");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/role/export" {:content-type :json
                                                               :form-params {:pageNum ""
                                                                             :pageSize ""
                                                                             :params ""
                                                                             :orderByColumn ""
                                                                             :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/role/export"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/role/export"),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/role/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/export"

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/role/export HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/role/export")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/export"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/export")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/role/export")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/role/export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/role/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/export',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/export")
  .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/system/role/export',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/role/export',
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  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}}/system/role/export');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/role/export',
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/export';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/export"]
                                                       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}}/system/role/export" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/export",
  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([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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}}/system/role/export', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/export');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/export');
$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}}/system/role/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/role/export", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/export"

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/export"

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/role/export")

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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/system/role/export') do |req|
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/export";

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    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}}/system/role/export \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http POST {{baseUrl}}/system/role/export \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/export

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/export")! 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()

PUT 角色管理-修改

{{baseUrl}}/system/role

BODY json

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role");

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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role" {:content-type :json
                                                       :form-params {:roleName ""
                                                                     :roleKey ""
                                                                     :roleSort ""
                                                                     :status ""
                                                                     :dataScope ""
                                                                     :remark ""
                                                                     :roleId ""}})

require "http/client"

url = "{{baseUrl}}/system/role"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role"),
    Content = new StringContent("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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}}/system/role");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role"

	payload := strings.NewReader("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 122

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role")
  .header("content-type", "application/json")
  .body("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role',
  headers: {'content-type': 'application/json'},
  data: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":"","roleId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": "",\n  "roleId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role',
  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({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role',
  headers: {'content-type': 'application/json'},
  body: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role',
  headers: {'content-type': 'application/json'},
  data: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":"","roleId":""}'
};

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 = @{ @"roleName": @"",
                              @"roleKey": @"",
                              @"roleSort": @"",
                              @"status": @"",
                              @"dataScope": @"",
                              @"remark": @"",
                              @"roleId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'roleName' => '',
    'roleKey' => '',
    'roleSort' => '',
    'status' => '',
    'dataScope' => '',
    'remark' => '',
    'roleId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role', [
  'body' => '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => '',
  'roleId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => '',
  'roleId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role"

payload = {
    "roleName": "",
    "roleKey": "",
    "roleSort": "",
    "status": "",
    "dataScope": "",
    "remark": "",
    "roleId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role"

payload <- "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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.put('/baseUrl/system/role') do |req|
  req.body = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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}}/system/role";

    let payload = json!({
        "roleName": "",
        "roleKey": "",
        "roleSort": "",
        "status": "",
        "dataScope": "",
        "remark": "",
        "roleId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role \
  --header 'content-type: application/json' \
  --data '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

echo '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}' |  \
  http PUT {{baseUrl}}/system/role \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": "",\n  "roleId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 角色管理-停用角色

{{baseUrl}}/system/role/changeStatus

BODY json

{
  "userId": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/changeStatus");

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  \"userId\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role/changeStatus" {:content-type :json
                                                                    :form-params {:userId ""
                                                                                  :status ""}})

require "http/client"

url = "{{baseUrl}}/system/role/changeStatus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role/changeStatus"),
    Content = new StringContent("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/role/changeStatus");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/changeStatus"

	payload := strings.NewReader("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role/changeStatus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "userId": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role/changeStatus")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/changeStatus"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/changeStatus")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role/changeStatus")
  .header("content-type", "application/json")
  .body("{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  userId: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role/changeStatus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/changeStatus',
  headers: {'content-type': 'application/json'},
  data: {userId: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/changeStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/changeStatus',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "userId": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/changeStatus")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/changeStatus',
  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({userId: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/changeStatus',
  headers: {'content-type': 'application/json'},
  body: {userId: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role/changeStatus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  userId: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/changeStatus',
  headers: {'content-type': 'application/json'},
  data: {userId: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/changeStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"userId":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"userId": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/changeStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role/changeStatus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/changeStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'userId' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role/changeStatus', [
  'body' => '{
  "userId": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/changeStatus');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'userId' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'userId' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/changeStatus');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/changeStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/changeStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "userId": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role/changeStatus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/changeStatus"

payload = {
    "userId": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/changeStatus"

payload <- "{\n  \"userId\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/changeStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"userId\": \"\",\n  \"status\": \"\"\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.put('/baseUrl/system/role/changeStatus') do |req|
  req.body = "{\n  \"userId\": \"\",\n  \"status\": \"\"\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}}/system/role/changeStatus";

    let payload = json!({
        "userId": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role/changeStatus \
  --header 'content-type: application/json' \
  --data '{
  "userId": "",
  "status": ""
}'

echo '{
  "userId": "",
  "status": ""
}' |  \
  http PUT {{baseUrl}}/system/role/changeStatus \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "userId": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/changeStatus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "userId": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/changeStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 角色管理-列表

{{baseUrl}}/system/role/list

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/list?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/role/list" {:query-params {:pageNum ""
                                                                           :pageSize ""}
                                                            :content-type :json
                                                            :form-params {:pageNum ""
                                                                          :pageSize ""
                                                                          :params ""
                                                                          :orderByColumn ""
                                                                          :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/role/list?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/role/list?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/role/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/list?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/system/role/list?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/role/list?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/list?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/role/list?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/role/list?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/list?pageNum=&pageSize=',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/list',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/role/list');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/role/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/list?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/role/list?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/list?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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('GET', '{{baseUrl}}/system/role/list?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/list');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/role/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/system/role/list?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/list"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/list?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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.get('/baseUrl/system/role/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/role/list?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http GET '{{baseUrl}}/system/role/list?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/role/list?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 角色管理-创建

{{baseUrl}}/system/role

BODY json

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role");

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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/role" {:content-type :json
                                                        :form-params {:roleName ""
                                                                      :roleKey ""
                                                                      :roleSort ""
                                                                      :status ""
                                                                      :dataScope ""
                                                                      :remark ""}})

require "http/client"

url = "{{baseUrl}}/system/role"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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}}/system/role"),
    Content = new StringContent("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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}}/system/role");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role"

	payload := strings.NewReader("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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/system/role HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 106

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/role")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/role")
  .header("content-type", "application/json")
  .body("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/role');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/role',
  headers: {'content-type': 'application/json'},
  data: {roleName: '', roleKey: '', roleSort: '', status: '', dataScope: '', remark: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role")
  .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/system/role',
  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({roleName: '', roleKey: '', roleSort: '', status: '', dataScope: '', remark: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/role',
  headers: {'content-type': 'application/json'},
  body: {roleName: '', roleKey: '', roleSort: '', status: '', dataScope: '', remark: ''},
  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}}/system/role');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: ''
});

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}}/system/role',
  headers: {'content-type': 'application/json'},
  data: {roleName: '', roleKey: '', roleSort: '', status: '', dataScope: '', remark: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":""}'
};

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 = @{ @"roleName": @"",
                              @"roleKey": @"",
                              @"roleSort": @"",
                              @"status": @"",
                              @"dataScope": @"",
                              @"remark": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role"]
                                                       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}}/system/role" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role",
  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([
    'roleName' => '',
    'roleKey' => '',
    'roleSort' => '',
    'status' => '',
    'dataScope' => '',
    'remark' => ''
  ]),
  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}}/system/role', [
  'body' => '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role');
$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}}/system/role' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/role", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role"

payload = {
    "roleName": "",
    "roleKey": "",
    "roleSort": "",
    "status": "",
    "dataScope": "",
    "remark": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role"

payload <- "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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}}/system/role")

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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\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/system/role') do |req|
  req.body = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role";

    let payload = json!({
        "roleName": "",
        "roleKey": "",
        "roleSort": "",
        "status": "",
        "dataScope": "",
        "remark": ""
    });

    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}}/system/role \
  --header 'content-type: application/json' \
  --data '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}'

echo '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
}' |  \
  http POST {{baseUrl}}/system/role \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role")! 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()

PUT 角色管理-批量绑定角色

{{baseUrl}}/system/role/authUser/selectAll

BODY json

{
  "roleId": "",
  "userIds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/authUser/selectAll");

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  \"roleId\": \"\",\n  \"userIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role/authUser/selectAll" {:content-type :json
                                                                          :form-params {:roleId ""
                                                                                        :userIds ""}})

require "http/client"

url = "{{baseUrl}}/system/role/authUser/selectAll"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role/authUser/selectAll"),
    Content = new StringContent("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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}}/system/role/authUser/selectAll");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/authUser/selectAll"

	payload := strings.NewReader("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role/authUser/selectAll HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "roleId": "",
  "userIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role/authUser/selectAll")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/authUser/selectAll"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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  \"roleId\": \"\",\n  \"userIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/selectAll")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role/authUser/selectAll")
  .header("content-type", "application/json")
  .body("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleId: '',
  userIds: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role/authUser/selectAll');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/selectAll',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/authUser/selectAll';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userIds":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/authUser/selectAll',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleId": "",\n  "userIds": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/selectAll")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/authUser/selectAll',
  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({roleId: '', userIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/selectAll',
  headers: {'content-type': 'application/json'},
  body: {roleId: '', userIds: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role/authUser/selectAll');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleId: '',
  userIds: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/selectAll',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/authUser/selectAll';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userIds":""}'
};

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 = @{ @"roleId": @"",
                              @"userIds": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/authUser/selectAll"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role/authUser/selectAll" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/authUser/selectAll",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'roleId' => '',
    'userIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role/authUser/selectAll', [
  'body' => '{
  "roleId": "",
  "userIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/authUser/selectAll');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleId' => '',
  'userIds' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleId' => '',
  'userIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/authUser/selectAll');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/authUser/selectAll' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userIds": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/authUser/selectAll' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userIds": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role/authUser/selectAll", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/authUser/selectAll"

payload = {
    "roleId": "",
    "userIds": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/authUser/selectAll"

payload <- "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/authUser/selectAll")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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.put('/baseUrl/system/role/authUser/selectAll') do |req|
  req.body = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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}}/system/role/authUser/selectAll";

    let payload = json!({
        "roleId": "",
        "userIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role/authUser/selectAll \
  --header 'content-type: application/json' \
  --data '{
  "roleId": "",
  "userIds": ""
}'

echo '{
  "roleId": "",
  "userIds": ""
}' |  \
  http PUT {{baseUrl}}/system/role/authUser/selectAll \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleId": "",\n  "userIds": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/authUser/selectAll

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleId": "",
  "userIds": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/authUser/selectAll")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 角色管理-批量解绑角色

{{baseUrl}}/system/role/authUser/cancelAll

BODY json

{
  "roleId": "",
  "userIds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/authUser/cancelAll");

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  \"roleId\": \"\",\n  \"userIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role/authUser/cancelAll" {:content-type :json
                                                                          :form-params {:roleId ""
                                                                                        :userIds ""}})

require "http/client"

url = "{{baseUrl}}/system/role/authUser/cancelAll"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role/authUser/cancelAll"),
    Content = new StringContent("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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}}/system/role/authUser/cancelAll");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/authUser/cancelAll"

	payload := strings.NewReader("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role/authUser/cancelAll HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "roleId": "",
  "userIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role/authUser/cancelAll")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/authUser/cancelAll"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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  \"roleId\": \"\",\n  \"userIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/cancelAll")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role/authUser/cancelAll")
  .header("content-type", "application/json")
  .body("{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleId: '',
  userIds: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role/authUser/cancelAll');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancelAll',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/authUser/cancelAll';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userIds":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/authUser/cancelAll',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleId": "",\n  "userIds": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/cancelAll")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/authUser/cancelAll',
  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({roleId: '', userIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancelAll',
  headers: {'content-type': 'application/json'},
  body: {roleId: '', userIds: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role/authUser/cancelAll');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleId: '',
  userIds: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancelAll',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/authUser/cancelAll';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userIds":""}'
};

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 = @{ @"roleId": @"",
                              @"userIds": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/authUser/cancelAll"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role/authUser/cancelAll" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/authUser/cancelAll",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'roleId' => '',
    'userIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role/authUser/cancelAll', [
  'body' => '{
  "roleId": "",
  "userIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/authUser/cancelAll');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleId' => '',
  'userIds' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleId' => '',
  'userIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/authUser/cancelAll');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/authUser/cancelAll' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userIds": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/authUser/cancelAll' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userIds": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role/authUser/cancelAll", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/authUser/cancelAll"

payload = {
    "roleId": "",
    "userIds": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/authUser/cancelAll"

payload <- "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/authUser/cancelAll")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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.put('/baseUrl/system/role/authUser/cancelAll') do |req|
  req.body = "{\n  \"roleId\": \"\",\n  \"userIds\": \"\"\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}}/system/role/authUser/cancelAll";

    let payload = json!({
        "roleId": "",
        "userIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role/authUser/cancelAll \
  --header 'content-type: application/json' \
  --data '{
  "roleId": "",
  "userIds": ""
}'

echo '{
  "roleId": "",
  "userIds": ""
}' |  \
  http PUT {{baseUrl}}/system/role/authUser/cancelAll \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleId": "",\n  "userIds": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/authUser/cancelAll

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleId": "",
  "userIds": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/authUser/cancelAll")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT 角色管理-数据权限修改

{{baseUrl}}/system/role/dataScope

BODY json

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/dataScope");

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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role/dataScope" {:content-type :json
                                                                 :form-params {:roleName ""
                                                                               :roleKey ""
                                                                               :roleSort ""
                                                                               :status ""
                                                                               :dataScope ""
                                                                               :remark ""
                                                                               :roleId ""}})

require "http/client"

url = "{{baseUrl}}/system/role/dataScope"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role/dataScope"),
    Content = new StringContent("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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}}/system/role/dataScope");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/dataScope"

	payload := strings.NewReader("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role/dataScope HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 122

{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role/dataScope")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/dataScope"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/dataScope")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role/dataScope")
  .header("content-type", "application/json")
  .body("{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role/dataScope');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/dataScope',
  headers: {'content-type': 'application/json'},
  data: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/dataScope';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":"","roleId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/dataScope',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": "",\n  "roleId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/dataScope")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/dataScope',
  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({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/dataScope',
  headers: {'content-type': 'application/json'},
  body: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role/dataScope');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleName: '',
  roleKey: '',
  roleSort: '',
  status: '',
  dataScope: '',
  remark: '',
  roleId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/dataScope',
  headers: {'content-type': 'application/json'},
  data: {
    roleName: '',
    roleKey: '',
    roleSort: '',
    status: '',
    dataScope: '',
    remark: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/dataScope';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleName":"","roleKey":"","roleSort":"","status":"","dataScope":"","remark":"","roleId":""}'
};

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 = @{ @"roleName": @"",
                              @"roleKey": @"",
                              @"roleSort": @"",
                              @"status": @"",
                              @"dataScope": @"",
                              @"remark": @"",
                              @"roleId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/dataScope"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role/dataScope" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/dataScope",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'roleName' => '',
    'roleKey' => '',
    'roleSort' => '',
    'status' => '',
    'dataScope' => '',
    'remark' => '',
    'roleId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role/dataScope', [
  'body' => '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/dataScope');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => '',
  'roleId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleName' => '',
  'roleKey' => '',
  'roleSort' => '',
  'status' => '',
  'dataScope' => '',
  'remark' => '',
  'roleId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/dataScope');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/dataScope' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/dataScope' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role/dataScope", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/dataScope"

payload = {
    "roleName": "",
    "roleKey": "",
    "roleSort": "",
    "status": "",
    "dataScope": "",
    "remark": "",
    "roleId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/dataScope"

payload <- "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/dataScope")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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.put('/baseUrl/system/role/dataScope') do |req|
  req.body = "{\n  \"roleName\": \"\",\n  \"roleKey\": \"\",\n  \"roleSort\": \"\",\n  \"status\": \"\",\n  \"dataScope\": \"\",\n  \"remark\": \"\",\n  \"roleId\": \"\"\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}}/system/role/dataScope";

    let payload = json!({
        "roleName": "",
        "roleKey": "",
        "roleSort": "",
        "status": "",
        "dataScope": "",
        "remark": "",
        "roleId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role/dataScope \
  --header 'content-type: application/json' \
  --data '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}'

echo '{
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
}' |  \
  http PUT {{baseUrl}}/system/role/dataScope \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleName": "",\n  "roleKey": "",\n  "roleSort": "",\n  "status": "",\n  "dataScope": "",\n  "remark": "",\n  "roleId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/dataScope

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleName": "",
  "roleKey": "",
  "roleSort": "",
  "status": "",
  "dataScope": "",
  "remark": "",
  "roleId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/dataScope")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 角色管理-角色已分配用户列表

{{baseUrl}}/system/role/authUser/allocatedList

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/role/authUser/allocatedList" {:query-params {:pageNum ""
                                                                                             :pageSize ""}
                                                                              :content-type :json
                                                                              :form-params {:pageNum ""
                                                                                            :pageSize ""
                                                                                            :params ""
                                                                                            :orderByColumn ""
                                                                                            :isAsc ""
                                                                                            :userName ""
                                                                                            :phonenumber ""
                                                                                            :roleId ""}})

require "http/client"

url = "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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}}/system/role/authUser/allocatedList?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/system/role/authUser/allocatedList?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/authUser/allocatedList',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","userName":"","phonenumber":"","roleId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "userName": "",\n  "phonenumber": "",\n  "roleId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/authUser/allocatedList?pageNum=&pageSize=',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/authUser/allocatedList',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/role/authUser/allocatedList');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
});

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}}/system/role/authUser/allocatedList',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","userName":"","phonenumber":"","roleId":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"userName": @"",
                              @"phonenumber": @"",
                              @"roleId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/role/authUser/allocatedList?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'userName' => '',
    'phonenumber' => '',
    'roleId' => ''
  ]),
  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('GET', '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/authUser/allocatedList');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'userName' => '',
  'phonenumber' => '',
  'roleId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'userName' => '',
  'phonenumber' => '',
  'roleId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/authUser/allocatedList');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/role/authUser/allocatedList?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/system/role/authUser/allocatedList?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/authUser/allocatedList"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "userName": "",
    "phonenumber": "",
    "roleId": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/authUser/allocatedList"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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.get('/baseUrl/system/role/authUser/allocatedList') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/authUser/allocatedList";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "userName": "",
        "phonenumber": "",
        "roleId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}' |  \
  http GET '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "userName": "",\n  "phonenumber": "",\n  "roleId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/authUser/allocatedList?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 角色管理-角色未分配用户列表

{{baseUrl}}/system/role/authUser/unallocatedList

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/role/authUser/unallocatedList" {:query-params {:pageNum ""
                                                                                               :pageSize ""}
                                                                                :content-type :json
                                                                                :form-params {:pageNum ""
                                                                                              :pageSize ""
                                                                                              :params ""
                                                                                              :orderByColumn ""
                                                                                              :isAsc ""
                                                                                              :userName ""
                                                                                              :phonenumber ""
                                                                                              :roleId ""}})

require "http/client"

url = "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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}}/system/role/authUser/unallocatedList?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/system/role/authUser/unallocatedList?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 146

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/authUser/unallocatedList',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","userName":"","phonenumber":"","roleId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "userName": "",\n  "phonenumber": "",\n  "roleId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/authUser/unallocatedList?pageNum=&pageSize=',
  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({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/role/authUser/unallocatedList',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/role/authUser/unallocatedList');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: '',
  userName: '',
  phonenumber: '',
  roleId: ''
});

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}}/system/role/authUser/unallocatedList',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {
    pageNum: '',
    pageSize: '',
    params: '',
    orderByColumn: '',
    isAsc: '',
    userName: '',
    phonenumber: '',
    roleId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":"","userName":"","phonenumber":"","roleId":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"",
                              @"userName": @"",
                              @"phonenumber": @"",
                              @"roleId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/role/authUser/unallocatedList?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => '',
    'userName' => '',
    'phonenumber' => '',
    'roleId' => ''
  ]),
  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('GET', '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/authUser/unallocatedList');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'userName' => '',
  'phonenumber' => '',
  'roleId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => '',
  'userName' => '',
  'phonenumber' => '',
  'roleId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/authUser/unallocatedList');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/role/authUser/unallocatedList?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/system/role/authUser/unallocatedList?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/authUser/unallocatedList"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": "",
    "userName": "",
    "phonenumber": "",
    "roleId": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/authUser/unallocatedList"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\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.get('/baseUrl/system/role/authUser/unallocatedList') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\",\n  \"userName\": \"\",\n  \"phonenumber\": \"\",\n  \"roleId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/authUser/unallocatedList";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": "",
        "userName": "",
        "phonenumber": "",
        "roleId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
}' |  \
  http GET '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": "",\n  "userName": "",\n  "phonenumber": "",\n  "roleId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": "",
  "userName": "",
  "phonenumber": "",
  "roleId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/authUser/unallocatedList?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()

PUT 角色管理-解绑角色

{{baseUrl}}/system/role/authUser/cancel

BODY json

{
  "roleId": "",
  "userId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/authUser/cancel");

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  \"roleId\": \"\",\n  \"userId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/role/authUser/cancel" {:content-type :json
                                                                       :form-params {:roleId ""
                                                                                     :userId ""}})

require "http/client"

url = "{{baseUrl}}/system/role/authUser/cancel"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/role/authUser/cancel"),
    Content = new StringContent("{\n  \"roleId\": \"\",\n  \"userId\": \"\"\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}}/system/role/authUser/cancel");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/authUser/cancel"

	payload := strings.NewReader("{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/role/authUser/cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "roleId": "",
  "userId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/role/authUser/cancel")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/authUser/cancel"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"roleId\": \"\",\n  \"userId\": \"\"\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  \"roleId\": \"\",\n  \"userId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/role/authUser/cancel")
  .header("content-type", "application/json")
  .body("{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  roleId: '',
  userId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/role/authUser/cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancel',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/authUser/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/role/authUser/cancel',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleId": "",\n  "userId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/role/authUser/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/authUser/cancel',
  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({roleId: '', userId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancel',
  headers: {'content-type': 'application/json'},
  body: {roleId: '', userId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/role/authUser/cancel');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleId: '',
  userId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/role/authUser/cancel',
  headers: {'content-type': 'application/json'},
  data: {roleId: '', userId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/authUser/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"roleId":"","userId":""}'
};

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 = @{ @"roleId": @"",
                              @"userId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/role/authUser/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/role/authUser/cancel" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/authUser/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'roleId' => '',
    'userId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/role/authUser/cancel', [
  'body' => '{
  "roleId": "",
  "userId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/authUser/cancel');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleId' => '',
  'userId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleId' => '',
  'userId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/role/authUser/cancel');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/authUser/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/authUser/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "roleId": "",
  "userId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/role/authUser/cancel", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/authUser/cancel"

payload = {
    "roleId": "",
    "userId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/authUser/cancel"

payload <- "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/authUser/cancel")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\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.put('/baseUrl/system/role/authUser/cancel') do |req|
  req.body = "{\n  \"roleId\": \"\",\n  \"userId\": \"\"\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}}/system/role/authUser/cancel";

    let payload = json!({
        "roleId": "",
        "userId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/role/authUser/cancel \
  --header 'content-type: application/json' \
  --data '{
  "roleId": "",
  "userId": ""
}'

echo '{
  "roleId": "",
  "userId": ""
}' |  \
  http PUT {{baseUrl}}/system/role/authUser/cancel \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleId": "",\n  "userId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/role/authUser/cancel

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleId": "",
  "userId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/authUser/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 角色管理-详情

{{baseUrl}}/system/role/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/role/:id")

require "http/client"

url = "{{baseUrl}}/system/role/: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}}/system/role/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/role/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/: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/system/role/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/role/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/: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}}/system/role/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/role/: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}}/system/role/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/role/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/: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}}/system/role/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/role/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/: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}}/system/role/: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}}/system/role/: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}}/system/role/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/: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}}/system/role/: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}}/system/role/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/: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}}/system/role/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/role/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/role/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/: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/system/role/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/: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}}/system/role/:id

http GET {{baseUrl}}/system/role/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/role/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/: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()

GET 角色管理-部门树

{{baseUrl}}/system/role/deptTree/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/role/deptTree/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/role/deptTree/:id")

require "http/client"

url = "{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/role/deptTree/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/role/deptTree/: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/system/role/deptTree/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/role/deptTree/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/role/deptTree/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/role/deptTree/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/role/deptTree/: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}}/system/role/deptTree/: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}}/system/role/deptTree/: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}}/system/role/deptTree/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/: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}}/system/role/deptTree/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/role/deptTree/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/role/deptTree/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/role/deptTree/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/role/deptTree/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/role/deptTree/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/role/deptTree/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/role/deptTree/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/role/deptTree/: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/system/role/deptTree/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/role/deptTree/: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}}/system/role/deptTree/:id

http GET {{baseUrl}}/system/role/deptTree/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/role/deptTree/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/role/deptTree/: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()

POST 合并切片

{{baseUrl}}/common/upload/chunk/merge

BODY json

{
  "uploadId": "",
  "fileName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload/chunk/merge");

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  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/common/upload/chunk/merge" {:content-type :json
                                                                      :form-params {:uploadId ""
                                                                                    :fileName ""}})

require "http/client"

url = "{{baseUrl}}/common/upload/chunk/merge"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\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}}/common/upload/chunk/merge"),
    Content = new StringContent("{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\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}}/common/upload/chunk/merge");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload/chunk/merge"

	payload := strings.NewReader("{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\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/common/upload/chunk/merge HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "uploadId": "",
  "fileName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/common/upload/chunk/merge")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload/chunk/merge"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\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  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/common/upload/chunk/merge")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/common/upload/chunk/merge")
  .header("content-type", "application/json")
  .body("{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  uploadId: '',
  fileName: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/common/upload/chunk/merge');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/common/upload/chunk/merge',
  headers: {'content-type': 'application/json'},
  data: {uploadId: '', fileName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload/chunk/merge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"uploadId":"","fileName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/common/upload/chunk/merge',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "uploadId": "",\n  "fileName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/common/upload/chunk/merge")
  .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/common/upload/chunk/merge',
  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({uploadId: '', fileName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/common/upload/chunk/merge',
  headers: {'content-type': 'application/json'},
  body: {uploadId: '', fileName: ''},
  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}}/common/upload/chunk/merge');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  uploadId: '',
  fileName: ''
});

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}}/common/upload/chunk/merge',
  headers: {'content-type': 'application/json'},
  data: {uploadId: '', fileName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload/chunk/merge';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"uploadId":"","fileName":""}'
};

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 = @{ @"uploadId": @"",
                              @"fileName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/common/upload/chunk/merge"]
                                                       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}}/common/upload/chunk/merge" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload/chunk/merge",
  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([
    'uploadId' => '',
    'fileName' => ''
  ]),
  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}}/common/upload/chunk/merge', [
  'body' => '{
  "uploadId": "",
  "fileName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload/chunk/merge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'uploadId' => '',
  'fileName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'uploadId' => '',
  'fileName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/common/upload/chunk/merge');
$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}}/common/upload/chunk/merge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "uploadId": "",
  "fileName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload/chunk/merge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "uploadId": "",
  "fileName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/common/upload/chunk/merge", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload/chunk/merge"

payload = {
    "uploadId": "",
    "fileName": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload/chunk/merge"

payload <- "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\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}}/common/upload/chunk/merge")

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  \"uploadId\": \"\",\n  \"fileName\": \"\"\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/common/upload/chunk/merge') do |req|
  req.body = "{\n  \"uploadId\": \"\",\n  \"fileName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload/chunk/merge";

    let payload = json!({
        "uploadId": "",
        "fileName": ""
    });

    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}}/common/upload/chunk/merge \
  --header 'content-type: application/json' \
  --data '{
  "uploadId": "",
  "fileName": ""
}'

echo '{
  "uploadId": "",
  "fileName": ""
}' |  \
  http POST {{baseUrl}}/common/upload/chunk/merge \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "uploadId": "",\n  "fileName": ""\n}' \
  --output-document \
  - {{baseUrl}}/common/upload/chunk/merge

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "uploadId": "",
  "fileName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload/chunk/merge")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 文件上传

{{baseUrl}}/common/upload

BODY json

{
  "file": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload");

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  \"file\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/common/upload" {:content-type :json
                                                          :form-params {:file ""}})

require "http/client"

url = "{{baseUrl}}/common/upload"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"file\": \"\"\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}}/common/upload"),
    Content = new StringContent("{\n  \"file\": \"\"\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}}/common/upload");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"file\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload"

	payload := strings.NewReader("{\n  \"file\": \"\"\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/common/upload HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "file": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/common/upload")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"file\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"file\": \"\"\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  \"file\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/common/upload")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/common/upload")
  .header("content-type", "application/json")
  .body("{\n  \"file\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  file: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/common/upload');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/common/upload',
  headers: {'content-type': 'application/json'},
  data: {file: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"file":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/common/upload',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "file": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"file\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/common/upload")
  .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/common/upload',
  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({file: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/common/upload',
  headers: {'content-type': 'application/json'},
  body: {file: ''},
  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}}/common/upload');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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: 'POST',
  url: '{{baseUrl}}/common/upload',
  headers: {'content-type': 'application/json'},
  data: {file: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"file":""}'
};

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 = @{ @"file": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/common/upload"]
                                                       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}}/common/upload" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"file\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload",
  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([
    'file' => ''
  ]),
  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}}/common/upload', [
  'body' => '{
  "file": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'file' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'file' => ''
]));
$request->setRequestUrl('{{baseUrl}}/common/upload');
$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}}/common/upload' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "file": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "file": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"file\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/common/upload", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload"

payload = { "file": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload"

payload <- "{\n  \"file\": \"\"\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}}/common/upload")

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  \"file\": \"\"\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/common/upload') do |req|
  req.body = "{\n  \"file\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload";

    let payload = json!({"file": ""});

    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}}/common/upload \
  --header 'content-type: application/json' \
  --data '{
  "file": ""
}'

echo '{
  "file": ""
}' |  \
  http POST {{baseUrl}}/common/upload \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "file": ""\n}' \
  --output-document \
  - {{baseUrl}}/common/upload

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["file": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 文件切片上传

{{baseUrl}}/common/upload/chunk

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload/chunk");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/common/upload/chunk")

require "http/client"

url = "{{baseUrl}}/common/upload/chunk"

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}}/common/upload/chunk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/common/upload/chunk");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload/chunk"

	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/common/upload/chunk HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/common/upload/chunk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload/chunk"))
    .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}}/common/upload/chunk")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/common/upload/chunk")
  .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}}/common/upload/chunk');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/common/upload/chunk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload/chunk';
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}}/common/upload/chunk',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/common/upload/chunk")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/common/upload/chunk',
  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}}/common/upload/chunk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/common/upload/chunk');

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}}/common/upload/chunk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload/chunk';
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}}/common/upload/chunk"]
                                                       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}}/common/upload/chunk" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload/chunk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/common/upload/chunk');

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload/chunk');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/common/upload/chunk');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/common/upload/chunk' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload/chunk' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/common/upload/chunk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload/chunk"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload/chunk"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/common/upload/chunk")

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/common/upload/chunk') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload/chunk";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/common/upload/chunk

http POST {{baseUrl}}/common/upload/chunk

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/common/upload/chunk

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload/chunk")! 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()

GET 获取cos上传密钥

{{baseUrl}}/common/upload/cos/authorization

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload/cos/authorization");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/common/upload/cos/authorization")

require "http/client"

url = "{{baseUrl}}/common/upload/cos/authorization"

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}}/common/upload/cos/authorization"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/common/upload/cos/authorization");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload/cos/authorization"

	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/common/upload/cos/authorization HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/common/upload/cos/authorization")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload/cos/authorization"))
    .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}}/common/upload/cos/authorization")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/common/upload/cos/authorization")
  .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}}/common/upload/cos/authorization');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/common/upload/cos/authorization'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload/cos/authorization';
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}}/common/upload/cos/authorization',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/common/upload/cos/authorization")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/common/upload/cos/authorization',
  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}}/common/upload/cos/authorization'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/common/upload/cos/authorization');

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}}/common/upload/cos/authorization'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload/cos/authorization';
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}}/common/upload/cos/authorization"]
                                                       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}}/common/upload/cos/authorization" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload/cos/authorization",
  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}}/common/upload/cos/authorization');

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload/cos/authorization');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/common/upload/cos/authorization');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/common/upload/cos/authorization' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload/cos/authorization' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/common/upload/cos/authorization")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload/cos/authorization"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload/cos/authorization"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/common/upload/cos/authorization")

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/common/upload/cos/authorization') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload/cos/authorization";

    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}}/common/upload/cos/authorization

http GET {{baseUrl}}/common/upload/cos/authorization

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/common/upload/cos/authorization

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload/cos/authorization")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 获取切片上传任务Id

{{baseUrl}}/common/upload/chunk/uploadId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload/chunk/uploadId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/common/upload/chunk/uploadId")

require "http/client"

url = "{{baseUrl}}/common/upload/chunk/uploadId"

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}}/common/upload/chunk/uploadId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/common/upload/chunk/uploadId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload/chunk/uploadId"

	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/common/upload/chunk/uploadId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/common/upload/chunk/uploadId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload/chunk/uploadId"))
    .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}}/common/upload/chunk/uploadId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/common/upload/chunk/uploadId")
  .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}}/common/upload/chunk/uploadId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/common/upload/chunk/uploadId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload/chunk/uploadId';
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}}/common/upload/chunk/uploadId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/common/upload/chunk/uploadId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/common/upload/chunk/uploadId',
  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}}/common/upload/chunk/uploadId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/common/upload/chunk/uploadId');

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}}/common/upload/chunk/uploadId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload/chunk/uploadId';
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}}/common/upload/chunk/uploadId"]
                                                       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}}/common/upload/chunk/uploadId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload/chunk/uploadId",
  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}}/common/upload/chunk/uploadId');

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload/chunk/uploadId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/common/upload/chunk/uploadId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/common/upload/chunk/uploadId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload/chunk/uploadId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/common/upload/chunk/uploadId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload/chunk/uploadId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload/chunk/uploadId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/common/upload/chunk/uploadId")

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/common/upload/chunk/uploadId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload/chunk/uploadId";

    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}}/common/upload/chunk/uploadId

http GET {{baseUrl}}/common/upload/chunk/uploadId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/common/upload/chunk/uploadId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload/chunk/uploadId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 获取切片上传结果

{{baseUrl}}/common/upload/chunk/result

QUERY PARAMS

uploadId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/common/upload/chunk/result?uploadId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/common/upload/chunk/result" {:query-params {:uploadId ""}})

require "http/client"

url = "{{baseUrl}}/common/upload/chunk/result?uploadId="

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}}/common/upload/chunk/result?uploadId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/common/upload/chunk/result?uploadId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/common/upload/chunk/result?uploadId="

	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/common/upload/chunk/result?uploadId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/common/upload/chunk/result?uploadId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/common/upload/chunk/result?uploadId="))
    .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}}/common/upload/chunk/result?uploadId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/common/upload/chunk/result?uploadId=")
  .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}}/common/upload/chunk/result?uploadId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/common/upload/chunk/result',
  params: {uploadId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/common/upload/chunk/result?uploadId=';
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}}/common/upload/chunk/result?uploadId=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/common/upload/chunk/result?uploadId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/common/upload/chunk/result?uploadId=',
  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}}/common/upload/chunk/result',
  qs: {uploadId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/common/upload/chunk/result');

req.query({
  uploadId: ''
});

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}}/common/upload/chunk/result',
  params: {uploadId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/common/upload/chunk/result?uploadId=';
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}}/common/upload/chunk/result?uploadId="]
                                                       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}}/common/upload/chunk/result?uploadId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/common/upload/chunk/result?uploadId=",
  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}}/common/upload/chunk/result?uploadId=');

echo $response->getBody();

setUrl('{{baseUrl}}/common/upload/chunk/result');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'uploadId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/common/upload/chunk/result');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'uploadId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/common/upload/chunk/result?uploadId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/common/upload/chunk/result?uploadId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/common/upload/chunk/result?uploadId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/common/upload/chunk/result"

querystring = {"uploadId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/common/upload/chunk/result"

queryString <- list(uploadId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/common/upload/chunk/result?uploadId=")

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/common/upload/chunk/result') do |req|
  req.params['uploadId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/common/upload/chunk/result";

    let querystring = [
        ("uploadId", ""),
    ];

    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}}/common/upload/chunk/result?uploadId='

http GET '{{baseUrl}}/common/upload/chunk/result?uploadId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/common/upload/chunk/result?uploadId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/common/upload/chunk/result?uploadId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 通知公告-列表

{{baseUrl}}/system/notice/list

QUERY PARAMS

pageNum

pageSize

BODY json

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/notice/list?pageNum=&pageSize=");

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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/notice/list" {:query-params {:pageNum ""
                                                                             :pageSize ""}
                                                              :content-type :json
                                                              :form-params {:pageNum ""
                                                                            :pageSize ""
                                                                            :params ""
                                                                            :orderByColumn ""
                                                                            :isAsc ""}})

require "http/client"

url = "{{baseUrl}}/system/notice/list?pageNum=&pageSize="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

response = HTTP::Client.get url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/system/notice/list?pageNum=&pageSize="),
    Content = new StringContent("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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}}/system/notice/list?pageNum=&pageSize=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/notice/list?pageNum=&pageSize="

	payload := strings.NewReader("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/system/notice/list?pageNum=&pageSize= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/notice/list?pageNum=&pageSize=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/notice/list?pageNum=&pageSize="))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/notice/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/notice/list?pageNum=&pageSize=")
  .header("content-type", "application/json")
  .body("{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/system/notice/list?pageNum=&pageSize=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/notice/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/notice/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/notice/list?pageNum=&pageSize=',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/notice/list?pageNum=&pageSize=")
  .get()
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/notice/list?pageNum=&pageSize=',
  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({pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/system/notice/list',
  qs: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  body: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/notice/list');

req.query({
  pageNum: '',
  pageSize: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pageNum: '',
  pageSize: '',
  params: '',
  orderByColumn: '',
  isAsc: ''
});

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}}/system/notice/list',
  params: {pageNum: '', pageSize: ''},
  headers: {'content-type': 'application/json'},
  data: {pageNum: '', pageSize: '', params: '', orderByColumn: '', isAsc: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/notice/list?pageNum=&pageSize=';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"pageNum":"","pageSize":"","params":"","orderByColumn":"","isAsc":""}'
};

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 = @{ @"pageNum": @"",
                              @"pageSize": @"",
                              @"params": @"",
                              @"orderByColumn": @"",
                              @"isAsc": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/notice/list?pageNum=&pageSize="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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}}/system/notice/list?pageNum=&pageSize=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}" in

Client.call ~headers ~body `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/notice/list?pageNum=&pageSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'pageNum' => '',
    'pageSize' => '',
    'params' => '',
    'orderByColumn' => '',
    'isAsc' => ''
  ]),
  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('GET', '{{baseUrl}}/system/notice/list?pageNum=&pageSize=', [
  'body' => '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/notice/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNum' => '',
  'pageSize' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pageNum' => '',
  'pageSize' => '',
  'params' => '',
  'orderByColumn' => '',
  'isAsc' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/notice/list');
$request->setRequestMethod('GET');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'pageNum' => '',
  'pageSize' => ''
]));

$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}}/system/notice/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/notice/list?pageNum=&pageSize=' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("GET", "/baseUrl/system/notice/list?pageNum=&pageSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/notice/list"

querystring = {"pageNum":"","pageSize":""}

payload = {
    "pageNum": "",
    "pageSize": "",
    "params": "",
    "orderByColumn": "",
    "isAsc": ""
}
headers = {"content-type": "application/json"}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/notice/list"

queryString <- list(
  pageNum = "",
  pageSize = ""
)

payload <- "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"

encode <- "json"

response <- VERB("GET", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/notice/list?pageNum=&pageSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\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.get('/baseUrl/system/notice/list') do |req|
  req.params['pageNum'] = ''
  req.params['pageSize'] = ''
  req.body = "{\n  \"pageNum\": \"\",\n  \"pageSize\": \"\",\n  \"params\": \"\",\n  \"orderByColumn\": \"\",\n  \"isAsc\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/notice/list";

    let querystring = [
        ("pageNum", ""),
        ("pageSize", ""),
    ];

    let payload = json!({
        "pageNum": "",
        "pageSize": "",
        "params": "",
        "orderByColumn": "",
        "isAsc": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/system/notice/list?pageNum=&pageSize=' \
  --header 'content-type: application/json' \
  --data '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}'

echo '{
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
}' |  \
  http GET '{{baseUrl}}/system/notice/list?pageNum=&pageSize=' \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "pageNum": "",\n  "pageSize": "",\n  "params": "",\n  "orderByColumn": "",\n  "isAsc": ""\n}' \
  --output-document \
  - '{{baseUrl}}/system/notice/list?pageNum=&pageSize='

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pageNum": "",
  "pageSize": "",
  "params": "",
  "orderByColumn": "",
  "isAsc": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/notice/list?pageNum=&pageSize=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 通知公告-创建

{{baseUrl}}/system/notice

BODY json

{
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/notice");

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  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/notice" {:content-type :json
                                                          :form-params {:remark ""
                                                                        :status ""}})

require "http/client"

url = "{{baseUrl}}/system/notice"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/notice"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/notice");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/notice"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/system/notice HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/notice")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/notice"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/notice")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/notice")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/notice');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/notice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/notice',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/notice")
  .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/system/notice',
  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({remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  body: {remark: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/notice');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  remark: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/notice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"remark": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/notice"]
                                                       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}}/system/notice" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/notice",
  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([
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/system/notice', [
  'body' => '{
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/notice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/notice');
$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}}/system/notice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/notice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/notice", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/notice"

payload = {
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/notice"

payload <- "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/notice")

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  \"remark\": \"\",\n  \"status\": \"\"\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/system/notice') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/notice";

    let payload = json!({
        "remark": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/notice \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "status": ""
}'

echo '{
  "remark": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/system/notice \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/notice

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/notice")! 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()

DELETE 通知公告-删除

{{baseUrl}}/system/notice/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/notice/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/notice/:id")

require "http/client"

url = "{{baseUrl}}/system/notice/: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}}/system/notice/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/notice/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/notice/: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/system/notice/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/notice/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/notice/: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}}/system/notice/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/notice/: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}}/system/notice/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/notice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/notice/: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}}/system/notice/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/notice/: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/system/notice/: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}}/system/notice/: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}}/system/notice/: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}}/system/notice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/notice/: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}}/system/notice/: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}}/system/notice/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/notice/: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}}/system/notice/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/notice/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/notice/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/notice/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/notice/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/notice/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/notice/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/notice/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/notice/: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/system/notice/: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}}/system/notice/: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}}/system/notice/:id

http DELETE {{baseUrl}}/system/notice/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/notice/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/notice/: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()

PUT 通知公告-更新

{{baseUrl}}/system/notice

BODY json

{
  "remark": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/notice");

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  \"remark\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/notice" {:content-type :json
                                                         :form-params {:remark ""
                                                                       :status ""}})

require "http/client"

url = "{{baseUrl}}/system/notice"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/notice"),
    Content = new StringContent("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/notice");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/notice"

	payload := strings.NewReader("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/notice HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "remark": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/notice")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/notice"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/notice")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/notice")
  .header("content-type", "application/json")
  .body("{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remark: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/notice');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/notice';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/notice',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remark": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/notice")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/notice',
  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({remark: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  body: {remark: '', status: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/notice');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  remark: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/notice',
  headers: {'content-type': 'application/json'},
  data: {remark: '', status: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/notice';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"remark":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"remark": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/notice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/notice" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/notice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'remark' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/notice', [
  'body' => '{
  "remark": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/notice');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remark' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'remark' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/notice');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/notice' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/notice' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "remark": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/notice", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/notice"

payload = {
    "remark": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/notice"

payload <- "{\n  \"remark\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/notice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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.put('/baseUrl/system/notice') do |req|
  req.body = "{\n  \"remark\": \"\",\n  \"status\": \"\"\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}}/system/notice";

    let payload = json!({
        "remark": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/notice \
  --header 'content-type: application/json' \
  --data '{
  "remark": "",
  "status": ""
}'

echo '{
  "remark": "",
  "status": ""
}' |  \
  http PUT {{baseUrl}}/system/notice \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "remark": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/notice

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "remark": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/notice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 通知公告-详情

{{baseUrl}}/system/notice/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/notice/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/notice/:id")

require "http/client"

url = "{{baseUrl}}/system/notice/: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}}/system/notice/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/notice/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/notice/: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/system/notice/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/notice/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/notice/: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}}/system/notice/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/notice/: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}}/system/notice/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/notice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/notice/: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}}/system/notice/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/notice/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/notice/: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}}/system/notice/: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}}/system/notice/: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}}/system/notice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/notice/: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}}/system/notice/: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}}/system/notice/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/notice/: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}}/system/notice/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/notice/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/notice/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/notice/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/notice/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/notice/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/notice/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/notice/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/notice/: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/system/notice/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/notice/: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}}/system/notice/:id

http GET {{baseUrl}}/system/notice/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/notice/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/notice/: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()

GET 部门管理-列表

{{baseUrl}}/system/dept/list

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept/list");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/dept/list")

require "http/client"

url = "{{baseUrl}}/system/dept/list"

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}}/system/dept/list"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dept/list");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept/list"

	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/system/dept/list HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dept/list")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept/list"))
    .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}}/system/dept/list")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/dept/list")
  .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}}/system/dept/list');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dept/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept/list';
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}}/system/dept/list',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dept/list")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dept/list',
  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}}/system/dept/list'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/system/dept/list');

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}}/system/dept/list'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept/list';
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}}/system/dept/list"]
                                                       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}}/system/dept/list" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept/list",
  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}}/system/dept/list');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept/list');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/dept/list');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dept/list' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept/list' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/dept/list")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept/list"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept/list"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept/list")

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/system/dept/list') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dept/list";

    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}}/system/dept/list

http GET {{baseUrl}}/system/dept/list

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dept/list

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST 部门管理-创建

{{baseUrl}}/system/dept

BODY json

{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept");

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  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/system/dept" {:content-type :json
                                                        :form-params {:parentId ""
                                                                      :deptName ""
                                                                      :orderNum ""
                                                                      :leader ""
                                                                      :phone ""
                                                                      :email ""
                                                                      :status ""}})

require "http/client"

url = "{{baseUrl}}/system/dept"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\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}}/system/dept"),
    Content = new StringContent("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dept");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept"

	payload := strings.NewReader("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/system/dept HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/system/dept")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dept")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/system/dept")
  .header("content-type", "application/json")
  .body("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/system/dept');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  data: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"parentId":"","deptName":"","orderNum":"","leader":"","phone":"","email":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dept',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentId": "",\n  "deptName": "",\n  "orderNum": "",\n  "leader": "",\n  "phone": "",\n  "email": "",\n  "status": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dept")
  .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/system/dept',
  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({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  body: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/system/dept');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  data: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"parentId":"","deptName":"","orderNum":"","leader":"","phone":"","email":"","status":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"parentId": @"",
                              @"deptName": @"",
                              @"orderNum": @"",
                              @"leader": @"",
                              @"phone": @"",
                              @"email": @"",
                              @"status": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dept"]
                                                       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}}/system/dept" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept",
  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([
    'parentId' => '',
    'deptName' => '',
    'orderNum' => '',
    'leader' => '',
    'phone' => '',
    'email' => '',
    'status' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/system/dept', [
  'body' => '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentId' => '',
  'deptName' => '',
  'orderNum' => '',
  'leader' => '',
  'phone' => '',
  'email' => '',
  'status' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentId' => '',
  'deptName' => '',
  'orderNum' => '',
  'leader' => '',
  'phone' => '',
  'email' => '',
  'status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dept');
$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}}/system/dept' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/system/dept", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept"

payload = {
    "parentId": "",
    "deptName": "",
    "orderNum": "",
    "leader": "",
    "phone": "",
    "email": "",
    "status": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept"

payload <- "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept")

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  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\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/system/dept') do |req|
  req.body = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dept";

    let payload = json!({
        "parentId": "",
        "deptName": "",
        "orderNum": "",
        "leader": "",
        "phone": "",
        "email": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/system/dept \
  --header 'content-type: application/json' \
  --data '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}'

echo '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
}' |  \
  http POST {{baseUrl}}/system/dept \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentId": "",\n  "deptName": "",\n  "orderNum": "",\n  "leader": "",\n  "phone": "",\n  "email": "",\n  "status": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dept

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept")! 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()

DELETE 部门管理-删除

{{baseUrl}}/system/dept/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/system/dept/:id")

require "http/client"

url = "{{baseUrl}}/system/dept/: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}}/system/dept/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dept/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept/: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/system/dept/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/system/dept/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept/: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}}/system/dept/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/system/dept/: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}}/system/dept/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/system/dept/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept/: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}}/system/dept/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dept/: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/system/dept/: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}}/system/dept/: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}}/system/dept/: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}}/system/dept/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept/: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}}/system/dept/: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}}/system/dept/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept/: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}}/system/dept/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/dept/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dept/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/system/dept/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept/: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/system/dept/: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}}/system/dept/: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}}/system/dept/:id

http DELETE {{baseUrl}}/system/dept/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/system/dept/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept/: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()

PUT 部门管理-更新

{{baseUrl}}/system/dept

BODY json

{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept");

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  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/system/dept" {:content-type :json
                                                       :form-params {:parentId ""
                                                                     :deptName ""
                                                                     :orderNum ""
                                                                     :leader ""
                                                                     :phone ""
                                                                     :email ""
                                                                     :status ""
                                                                     :deptId ""}})

require "http/client"

url = "{{baseUrl}}/system/dept"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/system/dept"),
    Content = new StringContent("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\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}}/system/dept");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept"

	payload := strings.NewReader("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/system/dept HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/system/dept")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\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  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/system/dept")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/system/dept")
  .header("content-type", "application/json")
  .body("{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: '',
  deptId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/system/dept');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  data: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: '',
    deptId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"parentId":"","deptName":"","orderNum":"","leader":"","phone":"","email":"","status":"","deptId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/system/dept',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentId": "",\n  "deptName": "",\n  "orderNum": "",\n  "leader": "",\n  "phone": "",\n  "email": "",\n  "status": "",\n  "deptId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/system/dept")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dept',
  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({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: '',
  deptId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  body: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: '',
    deptId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/system/dept');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentId: '',
  deptName: '',
  orderNum: '',
  leader: '',
  phone: '',
  email: '',
  status: '',
  deptId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/system/dept',
  headers: {'content-type': 'application/json'},
  data: {
    parentId: '',
    deptName: '',
    orderNum: '',
    leader: '',
    phone: '',
    email: '',
    status: '',
    deptId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"parentId":"","deptName":"","orderNum":"","leader":"","phone":"","email":"","status":"","deptId":""}'
};

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 = @{ @"parentId": @"",
                              @"deptName": @"",
                              @"orderNum": @"",
                              @"leader": @"",
                              @"phone": @"",
                              @"email": @"",
                              @"status": @"",
                              @"deptId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/system/dept"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/system/dept" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'parentId' => '',
    'deptName' => '',
    'orderNum' => '',
    'leader' => '',
    'phone' => '',
    'email' => '',
    'status' => '',
    'deptId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/system/dept', [
  'body' => '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentId' => '',
  'deptName' => '',
  'orderNum' => '',
  'leader' => '',
  'phone' => '',
  'email' => '',
  'status' => '',
  'deptId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentId' => '',
  'deptName' => '',
  'orderNum' => '',
  'leader' => '',
  'phone' => '',
  'email' => '',
  'status' => '',
  'deptId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/system/dept');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dept' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/system/dept", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept"

payload = {
    "parentId": "",
    "deptName": "",
    "orderNum": "",
    "leader": "",
    "phone": "",
    "email": "",
    "status": "",
    "deptId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept"

payload <- "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\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.put('/baseUrl/system/dept') do |req|
  req.body = "{\n  \"parentId\": \"\",\n  \"deptName\": \"\",\n  \"orderNum\": \"\",\n  \"leader\": \"\",\n  \"phone\": \"\",\n  \"email\": \"\",\n  \"status\": \"\",\n  \"deptId\": \"\"\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}}/system/dept";

    let payload = json!({
        "parentId": "",
        "deptName": "",
        "orderNum": "",
        "leader": "",
        "phone": "",
        "email": "",
        "status": "",
        "deptId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/system/dept \
  --header 'content-type: application/json' \
  --data '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}'

echo '{
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
}' |  \
  http PUT {{baseUrl}}/system/dept \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentId": "",\n  "deptName": "",\n  "orderNum": "",\n  "leader": "",\n  "phone": "",\n  "email": "",\n  "status": "",\n  "deptId": ""\n}' \
  --output-document \
  - {{baseUrl}}/system/dept

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "parentId": "",
  "deptName": "",
  "orderNum": "",
  "leader": "",
  "phone": "",
  "email": "",
  "status": "",
  "deptId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET 部门管理-详情

{{baseUrl}}/system/dept/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/dept/:id")

require "http/client"

url = "{{baseUrl}}/system/dept/: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}}/system/dept/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dept/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept/: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/system/dept/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dept/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept/: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}}/system/dept/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/dept/: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}}/system/dept/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dept/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept/: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}}/system/dept/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dept/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dept/: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}}/system/dept/: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}}/system/dept/: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}}/system/dept/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept/: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}}/system/dept/: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}}/system/dept/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept/: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}}/system/dept/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/dept/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dept/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/dept/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept/: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/system/dept/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dept/: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}}/system/dept/:id

http GET {{baseUrl}}/system/dept/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dept/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept/: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()

GET 部门管理-黑名单

{{baseUrl}}/system/dept/list/exclude/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/system/dept/list/exclude/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/system/dept/list/exclude/:id")

require "http/client"

url = "{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/system/dept/list/exclude/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/system/dept/list/exclude/: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/system/dept/list/exclude/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/system/dept/list/exclude/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/system/dept/list/exclude/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/system/dept/list/exclude/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/system/dept/list/exclude/: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}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/system/dept/list/exclude/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/system/dept/list/exclude/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/system/dept/list/exclude/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/system/dept/list/exclude/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/system/dept/list/exclude/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/system/dept/list/exclude/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/system/dept/list/exclude/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/system/dept/list/exclude/: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/system/dept/list/exclude/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/system/dept/list/exclude/: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}}/system/dept/list/exclude/:id

http GET {{baseUrl}}/system/dept/list/exclude/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/system/dept/list/exclude/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/system/dept/list/exclude/: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()