跳转至

配置管理☍

版本：v1

认证方式：Bearer Token

目录☍

接口列表☍

获取服务商列表☍

接口说明

根据业务代码和显示标志获取服务商列表

基本信息☍

  • 接口名称：获取服务商列表
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Providers

请求参数☍

Query 参数☍
参数名 类型 示例值 参数描述 是否必填
bizCode string - 业务代码 否
showFlag boolean - 是否显示 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Providers"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Providers"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Providers", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Providers',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Providers";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Providers");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Providers")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Providers", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Providers")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Providers")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务商的唯一标识符。,
          "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
          "name": ""          // 服务商的名称。,
          "code": ""          // 服务商的唯一代码，用于系统内部标识。,
          "icon": ""          // 服务商图标的URL或路径。,
          "description": ""          // 服务商的详细描述信息。,
          "tags": ""          // 用于分类或标记服务商的标签。,
          "show": false          // 指示服务商是否在界面上显示。,
          "showIndex": "0"          // 服务商在界面上的显示顺序。,
          "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array<ServiceProvider> 响应数据 否
error string 错误信息 否

添加服务商☍

接口说明

添加新的服务商

基本信息☍

  • 接口名称：添加服务商
  • 请求方式：POST
  • 请求路径：/ServiceSetting/Providers

请求参数☍

Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务商的唯一标识符。 否
bizCode string - 服务商的业务代码，用于标识其所属业务领域。 否
name string - 服务商的名称。 否
code string - 服务商的唯一代码，用于系统内部标识。 否
icon string - 服务商图标的URL或路径。 否
description string - 服务商的详细描述信息。 否
tags string - 用于分类或标记服务商的标签。 否
show boolean - 指示服务商是否在界面上显示。 否
showIndex integer - 服务商在界面上的显示顺序。 否
createDate string - 服务商记录的创建日期，默认为当前时间。 否
lastUpdate string - 服务商记录的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Providers"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import requests

url = "{server}/ServiceSetting/Providers"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/ServiceSetting/Providers", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
const axios = require('axios');


const data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

const config = {
    method: 'post',
    url: '{server}/ServiceSetting/Providers',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php

$url = "{server}/ServiceSetting/Providers";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/ServiceSetting/Providers", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Providers")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Providers", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Providers")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import Foundation

let url = URL(string: "{server}/ServiceSetting/Providers")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceSettingProviderPostResult - 否
error string 错误信息 否

获取服务商详情☍

接口说明

根据服务商ID获取服务商详情

基本信息☍

  • 接口名称：获取服务商详情
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Providers/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务商ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Providers/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Providers/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Providers/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Providers/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Providers/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Providers/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Providers/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Providers/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Providers/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Providers/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceProvider - 否
error string 错误信息 否

更新服务商☍

接口说明

根据服务商ID更新服务商信息

基本信息☍

  • 接口名称：更新服务商
  • 请求方式：PUT
  • 请求路径：/ServiceSetting/Providers/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务商ID 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务商的唯一标识符。 否
bizCode string - 服务商的业务代码，用于标识其所属业务领域。 否
name string - 服务商的名称。 否
code string - 服务商的唯一代码，用于系统内部标识。 否
icon string - 服务商图标的URL或路径。 否
description string - 服务商的详细描述信息。 否
tags string - 用于分类或标记服务商的标签。 否
show boolean - 指示服务商是否在界面上显示。 否
showIndex integer - 服务商在界面上的显示顺序。 否
createDate string - 服务商记录的创建日期，默认为当前时间。 否
lastUpdate string - 服务商记录的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Providers/{id}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("put", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import requests

url = "{server}/ServiceSetting/Providers/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/ServiceSetting/Providers/{id}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
const axios = require('axios');


const data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

const config = {
    method: 'put',
    url: '{server}/ServiceSetting/Providers/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php

$url = "{server}/ServiceSetting/Providers/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "put");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/ServiceSetting/Providers/{id}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Providers/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Providers/{id}", {
    method: "put",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Providers/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("put", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import Foundation

let url = URL(string: "{server}/ServiceSetting/Providers/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "put"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

删除服务商☍

接口说明

根据服务商ID删除服务商

基本信息☍

  • 接口名称：删除服务商
  • 请求方式：DELETE
  • 请求路径：/ServiceSetting/Providers/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务商ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Providers/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Providers/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/ServiceSetting/Providers/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/ServiceSetting/Providers/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Providers/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/ServiceSetting/Providers/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Providers/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Providers/{id}", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Providers/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Providers/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

获取服务分组列表☍

接口说明

根据服务商ID和显示标志获取服务分组列表

基本信息☍

  • 接口名称：获取服务分组列表
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Groups

请求参数☍

Query 参数☍
参数名 类型 示例值 参数描述 是否必填
providerId integer - 服务商ID 否
showFlag boolean - 是否显示 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Groups"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Groups"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Groups", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Groups',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Groups";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Groups");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Groups")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Groups", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Groups")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Groups")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务功能分组的唯一标识符。,
          "providerID": "0"          // 关联的服务商的唯一标识符。,
          "name": ""          // 服务功能分组的名称。,
          "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
          "icon": ""          // 服务功能分组的图标URL或路径。,
          "description": ""          // 服务功能分组的详细描述信息。,
          "show": false          // 指示服务功能分组是否在界面上显示。,
          "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
          "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array<ServiceGroup> 响应数据 否
error string 错误信息 否

添加服务分组☍

接口说明

添加新的服务分组

基本信息☍

  • 接口名称：添加服务分组
  • 请求方式：POST
  • 请求路径：/ServiceSetting/Groups

请求参数☍

Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务功能分组的唯一标识符。 否
providerID integer - 关联的服务商的唯一标识符。 否
name string - 服务功能分组的名称。 否
code string - 服务功能分组的唯一代码，用于系统内部标识。 否
icon string - 服务功能分组的图标URL或路径。 否
description string - 服务功能分组的详细描述信息。 否
show boolean - 指示服务功能分组是否在界面上显示。 否
showIndex integer - 服务功能分组在界面上的显示顺序。 否
createDate string - 服务功能分组的创建日期，默认为当前时间。 否
lastUpdate string - 服务功能分组的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Groups"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import requests

url = "{server}/ServiceSetting/Groups"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/ServiceSetting/Groups", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const axios = require('axios');


const data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

const config = {
    method: 'post',
    url: '{server}/ServiceSetting/Groups',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<?php

$url = "{server}/ServiceSetting/Groups";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/ServiceSetting/Groups", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Groups")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Groups", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Groups")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import Foundation

let url = URL(string: "{server}/ServiceSetting/Groups")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceSettingGroupPostResult - 否
error string 错误信息 否

获取服务分组详情☍

接口说明

根据服务分组ID获取服务分组详情

基本信息☍

  • 接口名称：获取服务分组详情
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Groups/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务分组ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Groups/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Groups/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Groups/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Groups/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Groups/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Groups/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Groups/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Groups/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Groups/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Groups/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceGroup - 否
error string 错误信息 否

更新服务分组☍

接口说明

根据服务分组ID更新服务分组信息

基本信息☍

  • 接口名称：更新服务分组
  • 请求方式：PUT
  • 请求路径：/ServiceSetting/Groups/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务分组ID 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务功能分组的唯一标识符。 否
providerID integer - 关联的服务商的唯一标识符。 否
name string - 服务功能分组的名称。 否
code string - 服务功能分组的唯一代码，用于系统内部标识。 否
icon string - 服务功能分组的图标URL或路径。 否
description string - 服务功能分组的详细描述信息。 否
show boolean - 指示服务功能分组是否在界面上显示。 否
showIndex integer - 服务功能分组在界面上的显示顺序。 否
createDate string - 服务功能分组的创建日期，默认为当前时间。 否
lastUpdate string - 服务功能分组的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Groups/{id}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("put", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import requests

url = "{server}/ServiceSetting/Groups/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/ServiceSetting/Groups/{id}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const axios = require('axios');


const data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

const config = {
    method: 'put',
    url: '{server}/ServiceSetting/Groups/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<?php

$url = "{server}/ServiceSetting/Groups/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "put");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/ServiceSetting/Groups/{id}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Groups/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Groups/{id}", {
    method: "put",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Groups/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("put", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import Foundation

let url = URL(string: "{server}/ServiceSetting/Groups/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "put"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

删除服务分组☍

接口说明

根据服务分组ID删除服务分组

基本信息☍

  • 接口名称：删除服务分组
  • 请求方式：DELETE
  • 请求路径：/ServiceSetting/Groups/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务分组ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Groups/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Groups/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/ServiceSetting/Groups/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/ServiceSetting/Groups/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Groups/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/ServiceSetting/Groups/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Groups/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Groups/{id}", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Groups/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Groups/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

服务配置列表☍

接口说明

根据业务代码、服务商代码、分组代码和显示标志获取服务配置列表

基本信息☍

  • 接口名称：服务配置列表
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Items

请求参数☍

Query 参数☍
参数名 类型 示例值 参数描述 是否必填
bizCode string - 业务代码 否
providerCode string - 服务商代码 否
groupCode string - 分组代码 否
showFlag boolean - 是否显示 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Items"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Items"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Items", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Items',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Items";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Items");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Items")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Items", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Items")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Items")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务配置项的唯一标识符。,
          "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
          "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
          "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
          "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
          "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
          "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
          "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
          "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
          "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
          "tags": ""          // 用于分类或标记服务配置项的标签。,
          "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
          "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
          "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
          "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array<ServiceItem> 响应数据 否
error string 错误信息 否

添加服务配置☍

接口说明

添加新的服务配置

基本信息☍

  • 接口名称：添加服务配置
  • 请求方式：POST
  • 请求路径：/ServiceSetting/Items

请求参数☍

Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务配置项的唯一标识符。 否
bizCode string - 服务配置项所属的业务代码，用于分类管理。 否
providerCode string - 关联的服务商代码，用于标识提供该配置项的服务商。 否
groupCode string - 服务配置项所属的功能分组代码，用于组织和管理相关配置项。 否
name string - 服务配置项的名称，用于描述其功能或用途。 否
code string - 服务配置项的唯一代码，用于系统内部标识。 否
valueType string - 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。 否
icon string - 服务配置项的图标URL或路径，用于在界面上显示。 否
valueDefaults string - 服务配置项的默认值，当未设置具体值时使用。 否
description string - 服务配置项的详细描述信息，用于说明其用途和配置方法。 否
tags string - 用于分类或标记服务配置项的标签。 否
isSystem boolean - 指示该配置项是否为系统级别的配置项，默认为 false。 否
show boolean - 指示服务配置项是否在界面上显示，默认为 true。 否
showIndex integer - 服务配置项在界面上的显示顺序。 否
createDate string - 服务配置项的创建日期，默认为当前时间。 否
lastUpdate string - 服务配置项的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Items"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import requests

url = "{server}/ServiceSetting/Items"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/ServiceSetting/Items", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
const axios = require('axios');


const data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

const config = {
    method: 'post',
    url: '{server}/ServiceSetting/Items',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<?php

$url = "{server}/ServiceSetting/Items";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/ServiceSetting/Items", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Items")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Items", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Items")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import Foundation

let url = URL(string: "{server}/ServiceSetting/Items")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceSettingItemPostResult - 否
error string 错误信息 否

服务配置详情☍

接口说明

根据服务配置ID获取服务配置详情

基本信息☍

  • 接口名称：服务配置详情
  • 请求方式：GET
  • 请求路径：/ServiceSetting/Items/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务配置ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Items/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Items/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/Items/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/Items/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Items/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/Items/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Items/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Items/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Items/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Items/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceItem - 否
error string 错误信息 否

更新服务配置☍

接口说明

根据服务配置ID更新服务配置信息

基本信息☍

  • 接口名称：更新服务配置
  • 请求方式：PUT
  • 请求路径：/ServiceSetting/Items/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务配置ID 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 服务配置项的唯一标识符。 否
bizCode string - 服务配置项所属的业务代码，用于分类管理。 否
providerCode string - 关联的服务商代码，用于标识提供该配置项的服务商。 否
groupCode string - 服务配置项所属的功能分组代码，用于组织和管理相关配置项。 否
name string - 服务配置项的名称，用于描述其功能或用途。 否
code string - 服务配置项的唯一代码，用于系统内部标识。 否
valueType string - 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。 否
icon string - 服务配置项的图标URL或路径，用于在界面上显示。 否
valueDefaults string - 服务配置项的默认值，当未设置具体值时使用。 否
description string - 服务配置项的详细描述信息，用于说明其用途和配置方法。 否
tags string - 用于分类或标记服务配置项的标签。 否
isSystem boolean - 指示该配置项是否为系统级别的配置项，默认为 false。 否
show boolean - 指示服务配置项是否在界面上显示，默认为 true。 否
showIndex integer - 服务配置项在界面上的显示顺序。 否
createDate string - 服务配置项的创建日期，默认为当前时间。 否
lastUpdate string - 服务配置项的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Items/{id}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("put", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import requests

url = "{server}/ServiceSetting/Items/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/ServiceSetting/Items/{id}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
const axios = require('axios');


const data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

const config = {
    method: 'put',
    url: '{server}/ServiceSetting/Items/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<?php

$url = "{server}/ServiceSetting/Items/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "put");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/ServiceSetting/Items/{id}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Items/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/Items/{id}", {
    method: "put",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Items/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("put", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import Foundation

let url = URL(string: "{server}/ServiceSetting/Items/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "put"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

删除服务配置☍

接口说明

根据服务配置ID删除服务配置

基本信息☍

  • 接口名称：删除服务配置
  • 请求方式：DELETE
  • 请求路径：/ServiceSetting/Items/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 服务配置ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/Items/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/Items/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/ServiceSetting/Items/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/ServiceSetting/Items/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/Items/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/ServiceSetting/Items/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/Items/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/Items/{id}", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/Items/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/Items/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

获取配置列表☍

接口说明

根据业务代码、业务标识、服务商代码、分组代码、标签和配置项代码获取配置列表

基本信息☍

  • 接口名称：获取配置列表
  • 请求方式：GET
  • 请求路径：/ServiceSetting

请求参数☍

Query 参数☍
参数名 类型 示例值 参数描述 是否必填
bizCode string - 业务代码 是
bizId string - 业务标识 是
providerCode string - 服务商代码 否
groupCode string - 分组代码 否
tag string - 标签 否
code string - 配置项代码 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 配置项的唯一标识符。,
          "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
          "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
          "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
          "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
          "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
          "value": ""          // 配置项的具体值，存储配置内容。,
          "tags": ""          // 用于分类或标记配置项的标签。,
          "description": ""          // 配置项的详细描述，说明其用途和作用。,
          "frontendUsable": false          // 指示该配置项是否可供前端使用。,
          "createDate": ""          // 配置项的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array<Settings> 响应数据 否
error string 错误信息 否

增加配置☍

接口说明

添加新的配置

基本信息☍

  • 接口名称：增加配置
  • 请求方式：POST
  • 请求路径：/ServiceSetting

请求参数☍

Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 配置项的唯一标识符。 否
bizCode string - 配置项所属的业务代码，用于分类管理。 否
bizIdentity string - 配置项所属的业务标识，用于唯一标识业务。 否
providerCode string - 配置项的提供者代码，用于标识配置来源。 否
groupCode string - 配置项的分组代码，用于组织和管理相关配置。 否
code string - 配置项的唯一代码，用于标识具体的配置项。 否
value string - 配置项的具体值，存储配置内容。 否
tags string - 用于分类或标记配置项的标签。 否
description string - 配置项的详细描述，说明其用途和作用。 否
frontendUsable boolean - 指示该配置项是否可供前端使用。 否
createDate string - 配置项的创建日期，默认为当前时间。 否
lastUpdate string - 配置项的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import requests

url = "{server}/ServiceSetting"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/ServiceSetting", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
const axios = require('axios');


const data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

const config = {
    method: 'post',
    url: '{server}/ServiceSetting',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php

$url = "{server}/ServiceSetting";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/ServiceSetting", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import Foundation

let url = URL(string: "{server}/ServiceSetting")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data ServiceSettingSettingPostResult - 否
error string 错误信息 否

获取配置详情☍

接口说明

根据配置ID获取配置详情

基本信息☍

  • 接口名称：获取配置详情
  • 请求方式：GET
  • 请求路径：/ServiceSetting/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 配置ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/ServiceSetting/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/ServiceSetting/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/ServiceSetting/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data Settings - 否
error string 错误信息 否

更新配置☍

接口说明

根据配置ID更新配置信息

基本信息☍

  • 接口名称：更新配置
  • 请求方式：PUT
  • 请求路径：/ServiceSetting/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 配置ID 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
id integer - 配置项的唯一标识符。 否
bizCode string - 配置项所属的业务代码，用于分类管理。 否
bizIdentity string - 配置项所属的业务标识，用于唯一标识业务。 否
providerCode string - 配置项的提供者代码，用于标识配置来源。 否
groupCode string - 配置项的分组代码，用于组织和管理相关配置。 否
code string - 配置项的唯一代码，用于标识具体的配置项。 否
value string - 配置项的具体值，存储配置内容。 否
tags string - 用于分类或标记配置项的标签。 否
description string - 配置项的详细描述，说明其用途和作用。 否
frontendUsable boolean - 指示该配置项是否可供前端使用。 否
createDate string - 配置项的创建日期，默认为当前时间。 否
lastUpdate string - 配置项的最后更新日期，默认为当前时间。 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/{id}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("put", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import requests

url = "{server}/ServiceSetting/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}

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

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/ServiceSetting/{id}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
const axios = require('axios');


const data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

const config = {
    method: 'put',
    url: '{server}/ServiceSetting/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php

$url = "{server}/ServiceSetting/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "put");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/ServiceSetting/{id}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
request.set_form_data(data)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};

fetch("{server}/ServiceSetting/{id}", {
    method: "put",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("put", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import Foundation

let url = URL(string: "{server}/ServiceSetting/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "put"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

删除配置☍

接口说明

根据配置ID删除配置

基本信息☍

  • 接口名称：删除配置
  • 请求方式：DELETE
  • 请求路径：/ServiceSetting/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
id - 配置ID 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/ServiceSetting/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/ServiceSetting/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/ServiceSetting/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/ServiceSetting/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/ServiceSetting/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/ServiceSetting/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/ServiceSetting/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

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

1
2
3
4
5
6
7
8
fetch("{server}/ServiceSetting/{id}", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/ServiceSetting/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/ServiceSetting/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

数据结构☍

BooleanApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

ServiceGroup☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
{
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
}
字段名 类型 描述 是否必填
id integer 服务功能分组的唯一标识符。 否
providerID integer 关联的服务商的唯一标识符。 否
name string 服务功能分组的名称。 否
code string 服务功能分组的唯一代码，用于系统内部标识。 否
icon string 服务功能分组的图标URL或路径。 否
description string 服务功能分组的详细描述信息。 否
show boolean 指示服务功能分组是否在界面上显示。 否
showIndex integer 服务功能分组在界面上的显示顺序。 否
createDate string 服务功能分组的创建日期，默认为当前时间。 否
lastUpdate string 服务功能分组的最后更新日期，默认为当前时间。 否

ServiceGroupApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务功能分组的唯一标识符。,
    "providerID": "0"          // 关联的服务商的唯一标识符。,
    "name": ""          // 服务功能分组的名称。,
    "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务功能分组的图标URL或路径。,
    "description": ""          // 服务功能分组的详细描述信息。,
    "show": false          // 指示服务功能分组是否在界面上显示。,
    "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
    "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceGroupListApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务功能分组的唯一标识符。,
          "providerID": "0"          // 关联的服务商的唯一标识符。,
          "name": ""          // 服务功能分组的名称。,
          "code": ""          // 服务功能分组的唯一代码，用于系统内部标识。,
          "icon": ""          // 服务功能分组的图标URL或路径。,
          "description": ""          // 服务功能分组的详细描述信息。,
          "show": false          // 指示服务功能分组是否在界面上显示。,
          "showIndex": "0"          // 服务功能分组在界面上的显示顺序。,
          "createDate": ""          // 服务功能分组的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务功能分组的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

ServiceItem☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
}
字段名 类型 描述 是否必填
id integer 服务配置项的唯一标识符。 否
bizCode string 服务配置项所属的业务代码，用于分类管理。 否
providerCode string 关联的服务商代码，用于标识提供该配置项的服务商。 否
groupCode string 服务配置项所属的功能分组代码，用于组织和管理相关配置项。 否
name string 服务配置项的名称，用于描述其功能或用途。 否
code string 服务配置项的唯一代码，用于系统内部标识。 否
valueType string 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。 否
icon string 服务配置项的图标URL或路径，用于在界面上显示。 否
valueDefaults string 服务配置项的默认值，当未设置具体值时使用。 否
description string 服务配置项的详细描述信息，用于说明其用途和配置方法。 否
tags string 用于分类或标记服务配置项的标签。 否
isSystem boolean 指示该配置项是否为系统级别的配置项，默认为 false。 否
show boolean 指示服务配置项是否在界面上显示，默认为 true。 否
showIndex integer 服务配置项在界面上的显示顺序。 否
createDate string 服务配置项的创建日期，默认为当前时间。 否
lastUpdate string 服务配置项的最后更新日期，默认为当前时间。 否

ServiceItemApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务配置项的唯一标识符。,
    "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
    "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
    "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
    "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
    "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
    "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
    "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
    "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
    "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
    "tags": ""          // 用于分类或标记服务配置项的标签。,
    "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
    "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
    "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
    "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceItemListApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务配置项的唯一标识符。,
          "bizCode": ""          // 服务配置项所属的业务代码，用于分类管理。,
          "providerCode": ""          // 关联的服务商代码，用于标识提供该配置项的服务商。,
          "groupCode": ""          // 服务配置项所属的功能分组代码，用于组织和管理相关配置项。,
          "name": ""          // 服务配置项的名称，用于描述其功能或用途。,
          "code": ""          // 服务配置项的唯一代码，用于系统内部标识。,
          "valueType": ""          // 服务配置项的值类型，例如 'text', 'number', 'boolean' 等。默认为 'text'。,
          "icon": ""          // 服务配置项的图标URL或路径，用于在界面上显示。,
          "valueDefaults": ""          // 服务配置项的默认值，当未设置具体值时使用。,
          "description": ""          // 服务配置项的详细描述信息，用于说明其用途和配置方法。,
          "tags": ""          // 用于分类或标记服务配置项的标签。,
          "isSystem": false          // 指示该配置项是否为系统级别的配置项，默认为 false。,
          "show": false          // 指示服务配置项是否在界面上显示，默认为 true。,
          "showIndex": "0"          // 服务配置项在界面上的显示顺序。,
          "createDate": ""          // 服务配置项的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务配置项的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

ServiceProvider☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
{
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
}
字段名 类型 描述 是否必填
id integer 服务商的唯一标识符。 否
bizCode string 服务商的业务代码，用于标识其所属业务领域。 否
name string 服务商的名称。 否
code string 服务商的唯一代码，用于系统内部标识。 否
icon string 服务商图标的URL或路径。 否
description string 服务商的详细描述信息。 否
tags string 用于分类或标记服务商的标签。 否
show boolean 指示服务商是否在界面上显示。 否
showIndex integer 服务商在界面上的显示顺序。 否
createDate string 服务商记录的创建日期，默认为当前时间。 否
lastUpdate string 服务商记录的最后更新日期，默认为当前时间。 否

ServiceProviderApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 服务商的唯一标识符。,
    "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
    "name": ""          // 服务商的名称。,
    "code": ""          // 服务商的唯一代码，用于系统内部标识。,
    "icon": ""          // 服务商图标的URL或路径。,
    "description": ""          // 服务商的详细描述信息。,
    "tags": ""          // 用于分类或标记服务商的标签。,
    "show": false          // 指示服务商是否在界面上显示。,
    "showIndex": "0"          // 服务商在界面上的显示顺序。,
    "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceProviderListApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 服务商的唯一标识符。,
          "bizCode": ""          // 服务商的业务代码，用于标识其所属业务领域。,
          "name": ""          // 服务商的名称。,
          "code": ""          // 服务商的唯一代码，用于系统内部标识。,
          "icon": ""          // 服务商图标的URL或路径。,
          "description": ""          // 服务商的详细描述信息。,
          "tags": ""          // 用于分类或标记服务商的标签。,
          "show": false          // 指示服务商是否在界面上显示。,
          "showIndex": "0"          // 服务商在界面上的显示顺序。,
          "createDate": ""          // 服务商记录的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 服务商记录的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

ServiceSettingGroupPostResult☍

1
2
3
{
    "id": "0"
}
字段名 类型 描述 是否必填
id integer - 否

ServiceSettingGroupPostResultApiResponse☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceSettingItemPostResult☍

1
2
3
{
    "id": "0"
}
字段名 类型 描述 是否必填
id integer - 否

ServiceSettingItemPostResultApiResponse☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceSettingProviderPostResult☍

1
2
3
{
    "id": "0"
}
字段名 类型 描述 是否必填
id integer - 否

ServiceSettingProviderPostResultApiResponse☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

ServiceSettingSettingPostResult☍

1
2
3
{
    "id": "0"
}
字段名 类型 描述 是否必填
id integer - 否

ServiceSettingSettingPostResultApiResponse☍

1
2
3
4
5
6
7
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

Settings☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
}
字段名 类型 描述 是否必填
id integer 配置项的唯一标识符。 否
bizCode string 配置项所属的业务代码，用于分类管理。 否
bizIdentity string 配置项所属的业务标识，用于唯一标识业务。 否
providerCode string 配置项的提供者代码，用于标识配置来源。 否
groupCode string 配置项的分组代码，用于组织和管理相关配置。 否
code string 配置项的唯一代码，用于标识具体的配置项。 否
value string 配置项的具体值，存储配置内容。 否
tags string 用于分类或标记配置项的标签。 否
description string 配置项的详细描述，说明其用途和作用。 否
frontendUsable boolean 指示该配置项是否可供前端使用。 否
createDate string 配置项的创建日期，默认为当前时间。 否
lastUpdate string 配置项的最后更新日期，默认为当前时间。 否

SettingsApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
{
    "code": 200          // 状态码,
    "data": {
    "id": "0"          // 配置项的唯一标识符。,
    "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
    "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
    "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
    "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
    "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
    "value": ""          // 配置项的具体值，存储配置内容。,
    "tags": ""          // 用于分类或标记配置项的标签。,
    "description": ""          // 配置项的详细描述，说明其用途和作用。,
    "frontendUsable": false          // 指示该配置项是否可供前端使用。,
    "createDate": ""          // 配置项的创建日期，默认为当前时间。,
    "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

SettingsListApiResponse☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
{
    "code": 200          // 状态码,
    "data": [
      {
          "id": "0"          // 配置项的唯一标识符。,
          "bizCode": ""          // 配置项所属的业务代码，用于分类管理。,
          "bizIdentity": ""          // 配置项所属的业务标识，用于唯一标识业务。,
          "providerCode": ""          // 配置项的提供者代码，用于标识配置来源。,
          "groupCode": ""          // 配置项的分组代码，用于组织和管理相关配置。,
          "code": ""          // 配置项的唯一代码，用于标识具体的配置项。,
          "value": ""          // 配置项的具体值，存储配置内容。,
          "tags": ""          // 用于分类或标记配置项的标签。,
          "description": ""          // 配置项的详细描述，说明其用途和作用。,
          "frontendUsable": false          // 指示该配置项是否可供前端使用。,
          "createDate": ""          // 配置项的创建日期，默认为当前时间。,
          "lastUpdate": ""          // 配置项的最后更新日期，默认为当前时间。
      }
    ]          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

通用错误码☍

错误码 说明
200 成功