跳转至

用户☍

版本：v1

认证方式：Bearer Token

目录☍

接口列表☍

UnionID登录☍

接口说明

使用UnionID进行登录

基本信息☍

  • 接口名称：UnionID登录
  • 请求方式：POST
  • 请求路径：/User/{appKey}/UnionIDSignIn

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
unionID string - UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符 是
platform string - 平台，长度必须在1到20个字符之间，只能包含字母和数字 是
twoFactorCode string - 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

示例代码☍

 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
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}/User/{appKey}/UnionIDSignIn"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import requests

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


data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/UnionIDSignIn", 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
const axios = require('axios');


const data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/UnionIDSignIn',
    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
<?php

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


$data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

$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
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 = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/UnionIDSignIn", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/UnionIDSignIn")
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 = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
const data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

fetch("{server}/User/{appKey}/UnionIDSignIn", {
    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
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}/User/{appKey}/UnionIDSignIn")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/UnionIDSignIn")!
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 = {
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

UnionID注册☍

接口说明

使用UnionID进行注册

基本信息☍

  • 接口名称：UnionID注册
  • 请求方式：POST
  • 请求路径：/User/{appKey}/UnionIDSignUp

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
userName string - 登录账号，可空，只能包含字母、数字、下划线和连字符 否
unionID string - UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符 是
platform string - 平台标识，长度必须在1到20个字符之间，只能包含字母和数字 是
pwd string - 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号 是
nickName string - 用户昵称 否
avatar string - 用户头像URL 否
data string - 自定义数据 否
email string - 用户邮箱 否
emailCode string - 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
phone string - 用户手机号，必须为11位数字 否
phoneCode string - 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字 否

示例代码☍

 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}/User/{appKey}/UnionIDSignUp"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
        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}/User/{appKey}/UnionIDSignUp"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}

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 := {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/UnionIDSignUp", 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 = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/UnionIDSignUp',
    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}/User/{appKey}/UnionIDSignUp";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

$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 = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/UnionIDSignUp", 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}/User/{appKey}/UnionIDSignUp")
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 = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
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 = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

fetch("{server}/User/{appKey}/UnionIDSignUp", {
    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}/User/{appKey}/UnionIDSignUp")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
        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}/User/{appKey}/UnionIDSignUp")!
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 = {
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

密码登录☍

接口说明

使用账号密码进行登录

基本信息☍

  • 接口名称：密码登录
  • 请求方式：POST
  • 请求路径：/User/{appKey}/SignIn

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
userName string - 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符 是
pwd string - 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号 是
twoFactorCode string - 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

示例代码☍

 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
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}/User/{appKey}/SignIn"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import requests

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


data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/SignIn", 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
const axios = require('axios');


const data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/SignIn',
    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
<?php

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


$data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

$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
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/SignIn", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/SignIn")
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
const data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

fetch("{server}/User/{appKey}/SignIn", {
    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
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}/User/{appKey}/SignIn")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/SignIn")!
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

账号注册☍

接口说明

使用账号密码进行注册

基本信息☍

  • 接口名称：账号注册
  • 请求方式：POST
  • 请求路径：/User/{appKey}/SignUp

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
userName string - 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符 是
pwd string - 登录密码，长度必须在6到32个字符之间，只能包含字母和数字 是
nickName string - 用户昵称，长度不能超过20个字符 否
avatar string - 用户头像URL 否
data string - 自定义数据 否
email string - 用户邮箱 否
emailCode string - 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
phone string - 用户手机号，必须为11位数字 否
phoneCode string - 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字 否

示例代码☍

 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
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}/User/{appKey}/SignUp"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
        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
import requests

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


data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/SignUp", 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
const axios = require('axios');


const data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/SignUp',
    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
<?php

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


$data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

$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
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/SignUp", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/SignUp")
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
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
const data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};

fetch("{server}/User/{appKey}/SignUp", {
    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
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}/User/{appKey}/SignUp")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/SignUp")!
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 = {
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

手机登录☍

接口说明

使用手机号码进行登录

基本信息☍

  • 接口名称：手机登录
  • 请求方式：POST
  • 请求路径：/User/{appKey}/PhoneSignIn

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
phone string - 用户手机号 是
verifyCode string - 验证码，长度为4到8位的数字 是
twoFactorCode string - 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

示例代码☍

 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
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}/User/{appKey}/PhoneSignIn"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import requests

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


data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/PhoneSignIn", 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
const axios = require('axios');


const data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/PhoneSignIn',
    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
<?php

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


$data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

$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
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 = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/PhoneSignIn", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/PhoneSignIn")
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 = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
const data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};

fetch("{server}/User/{appKey}/PhoneSignIn", {
    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
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}/User/{appKey}/PhoneSignIn")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/PhoneSignIn")!
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 = {
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

手机注册☍

接口说明

使用手机号码进行注册

基本信息☍

  • 接口名称：手机注册
  • 请求方式：POST
  • 请求路径：/User/{appKey}/PhoneSignUp

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
phone string - 用户手机号 是
phoneCode string - 手机验证码，长度为4到8位的数字 是
pwd string - 用户密码，长度为6到32个字符 是
email string - 用户邮箱 否
emailCode string - 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
nickName string - 用户昵称 否
avatar string - 用户头像URL 否
data 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
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}/User/{appKey}/PhoneSignUp"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
        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
import requests

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


data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/PhoneSignUp", 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
const axios = require('axios');


const data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/PhoneSignUp',
    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
<?php

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


$data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

$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
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 = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/PhoneSignUp", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/PhoneSignUp")
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 = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
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
const data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

fetch("{server}/User/{appKey}/PhoneSignUp", {
    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
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}/User/{appKey}/PhoneSignUp")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/PhoneSignUp")!
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 = {
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

邮箱登录☍

接口说明

使用邮箱进行登录

基本信息☍

  • 接口名称：邮箱登录
  • 请求方式：POST
  • 请求路径：/User/{appKey}/EmailSignIn

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
email string - 用户邮箱地址 是
verifyCode string - 验证码，长度为4到8位的数字 是
twoFactorCode 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
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}/User/{appKey}/EmailSignIn"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};
        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
import requests

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


data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/EmailSignIn", 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
const axios = require('axios');


const data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/EmailSignIn',
    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
<?php

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


$data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};

$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
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 = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/EmailSignIn", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/EmailSignIn")
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 = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
}
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
const data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};

fetch("{server}/User/{appKey}/EmailSignIn", {
    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
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}/User/{appKey}/EmailSignIn")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/EmailSignIn")!
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 = {
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

邮箱注册☍

接口说明

使用邮箱进行注册

基本信息☍

  • 接口名称：邮箱注册
  • 请求方式：POST
  • 请求路径：/User/{appKey}/EmailSignUp

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
email string - 用户邮箱地址 是
pwd string - 用户密码，长度为6到32个字符 是
emailCode string - 邮箱验证码 否
phone string - 手机号，必须为11位数字 否
phoneCode string - 手机验证码（只有启用的手机验证码功能时，才需要传入） 否
nickName string - 用户昵称 否
avatar string - 用户头像URL 否
data 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
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}/User/{appKey}/EmailSignUp"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
        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
import requests

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


data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/EmailSignUp", 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
const axios = require('axios');


const data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/EmailSignUp',
    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
<?php

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


$data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

$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
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 = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/EmailSignUp", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/EmailSignUp")
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 = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
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
const data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};

fetch("{server}/User/{appKey}/EmailSignUp", {
    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
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}/User/{appKey}/EmailSignUp")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/EmailSignUp")!
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 = {
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
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
8
9
{
    "code": 200          // 状态码,
    "data": {
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data TokenModel - 否
error string 错误信息 否

获取个人资料☍

接口说明

获取当前用户的个人资料

基本信息☍

  • 接口名称：获取个人资料
  • 请求方式：GET
  • 请求路径：/User/{appKey}/Profile

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是

示例代码☍

 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}/User/{appKey}/Profile"))
            .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}/User/{appKey}/Profile"
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}/User/{appKey}/Profile", 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}/User/{appKey}/Profile',
    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}/User/{appKey}/Profile";
$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}/User/{appKey}/Profile");

            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}/User/{appKey}/Profile")
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}/User/{appKey}/Profile", {
    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}/User/{appKey}/Profile")
            .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}/User/{appKey}/Profile")!
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
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
{
    "code": 200          // 状态码,
    "data": {
    "user": {
    "id": "0"          // 用户唯一标识,
    "platform": ""          // 用户所在平台,
    "unionID": ""          // 用户所在平台的唯一标识,
    "nickName": ""          // 昵称,
    "avatar": ""          // 头像,
    "data": ""          // 其他数据,
    "userName": ""          // 用户名,
    "pwd": ""          // 用户密码,
    "email": ""          // 邮箱地址,
    "emailIsValid": false          // 邮箱已验证,
    "phone": ""          // 手机号码,
    "phoneIsValid": false          // 手机号码已验证,
    "relationChain": ""          // 关系链,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介,
    "gender": ""          // 性别,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业,
    "education": ""          // 学历,
    "contact": ""          // 联系方式,
    "languages": ""          // 语言,
    "socialLinks": ""          // 社交网络链接,
    "relationshipStatus": ""          // 婚姻状态,
    "company": ""          // 公司,
    "industry": ""          // 行业,
    "companyPosition": ""          // 行业职位,
    "privateSettings": ""          // 私密设置,
    "isLock": false          // 账户是否锁定,
    "lockUntil": ""          // 账户锁定截止时间,
    "enableUserNameSignIn": false          // 能使用用户名登录,
    "enableEmailSignIn": false          // 能使用邮箱登录,
    "enablePhoneSignIn": false          // 能使用电话号码登录,
    "enableUnionIDSignIn": false          // 能使用联合身份标识登录,
    "enableOAuth": false          // 能使用OAuth认证方式登录,
    "enable2FAAuth": false          // 启用双因素认证登录,
    "createDate": ""          // 创建时间,
    "lastUpdate": ""          // 最后更新时间
},
    "currencies": [
      {
          "id": "0"          // 用户资产的唯一标识符。,
          "userID": "0"          // 与用户资产关联的用户ID。,
          "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
          "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
      }
    ],
    "role": ""
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data UserProfileResult - 否
error string 错误信息 否

更新个人资料☍

接口说明

更新当前用户的个人资料

基本信息☍

  • 接口名称：更新个人资料
  • 请求方式：PUT
  • 请求路径：/User/{appKey}/Profile

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
avatar string - 用户头像的链接或路径，长度不能超过255个字符 否
data string - 用户的其他数据，可以是序列化后的对象或JSON字符串 否
nickName string - 用户的昵称，长度不能超过50个字符 否
interestTags string - 兴趣标签 否
biography string - 个人简介，长度不能超过500个字符 否
gender string - 性别，长度不能超过15个字符 否
birthday string - 生日 否
occupation string - 职业，长度不能超过50个字符 否
education string - 学历，长度不能超过50个字符 否
contact string - 联系方式，长度不能超过255个字符 否
languages string - 语言，长度不能超过50个字符 否
socialLinks string - 社交网络链接，长度不能超过255个字符 否
relationshipStatus string - 婚姻状态，长度不能超过20个字符 否
company string - 公司，长度不能��过100个字符 否
industry string - 行业，长度不能超过50个字符 否
companyPosition string - 行业职位，长度不能超过50个字符 否
privateSettings string - 私密设置，长度不能超过500个字符 否
enable2FAAuth boolean - 是否启用二步验证 否
enableUserNameSignIn boolean - 是否启用账号登录 否
enableEmailSignIn boolean - 是否启用邮箱登录 否
enablePhoneSignIn boolean - 是否启用手机登录 否
enableUnionIDSignIn boolean - 是否启用UnionID登录 否
enableOAuth boolean - 是否启用OAuth2登录 否

示例代码☍

 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
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}/User/{appKey}/Profile"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};
        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
36
37
38
39
40
41
42
import requests

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


data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
}

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
62
63
64
65
66
67
68
package main

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

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

    var req *http.Request
    var err error


    data := {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/User/{appKey}/Profile", 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
40
41
42
43
44
45
46
const axios = require('axios');


const data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};

const config = {
    method: 'put',
    url: '{server}/User/{appKey}/Profile',
    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
40
41
42
43
44
45
46
<?php

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


$data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};

$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
47
48
49
50
51
52
53
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 = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/User/{appKey}/Profile", 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
35
36
37
38
39
40
41
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/Profile")
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 = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
}
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
30
31
32
33
34
35
36
const data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};

fetch("{server}/User/{appKey}/Profile", {
    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
49
50
51
52
53
54
55
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}/User/{appKey}/Profile")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
};
        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
39
40
41
42
43
44
45
import Foundation

let url = URL(string: "{server}/User/{appKey}/Profile")!
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 = {
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
}
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 错误信息 否

注销账号☍

接口说明

清除用户所有附属数据，并注销账号

基本信息☍

  • 接口名称：注销账号
  • 请求方式：DELETE
  • 请求路径：/User/{appKey}/DeactivateHard

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是

示例代码☍

 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}/User/{appKey}/DeactivateHard"))
            .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}/User/{appKey}/DeactivateHard"
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}/User/{appKey}/DeactivateHard", 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}/User/{appKey}/DeactivateHard',
    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}/User/{appKey}/DeactivateHard";
$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}/User/{appKey}/DeactivateHard");

            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}/User/{appKey}/DeactivateHard")
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}/User/{appKey}/DeactivateHard", {
    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}/User/{appKey}/DeactivateHard")
            .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}/User/{appKey}/DeactivateHard")!
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 错误信息 否

重置密码☍

接口说明

通过手机号或邮箱重置密码

基本信息☍

  • 接口名称：重置密码
  • 请求方式：POST
  • 请求路径：/User/{appKey}/ResetPwd

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
pwd string - 新的密码 是
oldpwd 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
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}/User/{appKey}/ResetPwd"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};
        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
import requests

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


data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/ResetPwd", 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
const axios = require('axios');


const data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/ResetPwd',
    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
<?php

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


$data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};

$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
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 = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/ResetPwd", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/ResetPwd")
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 = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
}
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
const data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};

fetch("{server}/User/{appKey}/ResetPwd", {
    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
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}/User/{appKey}/ResetPwd")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/ResetPwd")!
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 = {
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
}
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 错误信息 否

重置手机号☍

接口说明

通过手机号验证码重置手机号

基本信息☍

  • 接口名称：重置手机号
  • 请求方式：PUT
  • 请求路径：/User/{appKey}/ResetPhone

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
phone 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
28
29
30
31
32
33
34
35
36
37
38
39
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}/User/{appKey}/ResetPhone"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};
        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
import requests

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


data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/User/{appKey}/ResetPhone", 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
const axios = require('axios');


const data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};

const config = {
    method: 'put',
    url: '{server}/User/{appKey}/ResetPhone',
    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
<?php

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


$data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};

$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
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 = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/User/{appKey}/ResetPhone", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/ResetPhone")
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 = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
}
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
const data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};

fetch("{server}/User/{appKey}/ResetPhone", {
    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
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}/User/{appKey}/ResetPhone")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/ResetPhone")!
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 = {
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
}
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 错误信息 否

重置邮箱☍

接口说明

通过邮箱验证码重置邮箱

基本信息☍

  • 接口名称：重置邮箱
  • 请求方式：PUT
  • 请求路径：/User/{appKey}/ResetEmail

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
email 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
28
29
30
31
32
33
34
35
36
37
38
39
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}/User/{appKey}/ResetEmail"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};
        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
import requests

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


data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/User/{appKey}/ResetEmail", 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
const axios = require('axios');


const data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};

const config = {
    method: 'put',
    url: '{server}/User/{appKey}/ResetEmail',
    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
<?php

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


$data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};

$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
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 = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/User/{appKey}/ResetEmail", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/ResetEmail")
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 = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
}
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
const data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};

fetch("{server}/User/{appKey}/ResetEmail", {
    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
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}/User/{appKey}/ResetEmail")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/ResetEmail")!
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 = {
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
}
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 错误信息 否

发送手机验证码☍

接口说明

发送手机验证码用于注册或找回密码

基本信息☍

  • 接口名称：发送手机验证码
  • 请求方式：POST
  • 请求路径：/User/{appKey}/SendSMSCode

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
phone string - 用户手机号 是
type string - 用途。可选值：signup（注册）/forgetpwd（忘记密码） 是

示例代码☍

 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
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}/User/{appKey}/SendSMSCode"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
        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
import requests

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


data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/SendSMSCode", 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
const axios = require('axios');


const data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/SendSMSCode',
    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
<?php

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


$data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

$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
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 = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/SendSMSCode", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/SendSMSCode")
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 = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
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
const data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

fetch("{server}/User/{appKey}/SendSMSCode", {
    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
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}/User/{appKey}/SendSMSCode")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/SendSMSCode")!
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 = {
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
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 错误信息 否

发送邮箱验证码☍

接口说明

发送邮箱验证码用于注册或找回密码

基本信息☍

  • 接口名称：发送邮箱验证码
  • 请求方式：POST
  • 请求路径：/User/{appKey}/SendEmailCode

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
email string - 用户邮箱地址 是
type string - 用途。可选值：signup（注册）/forgetpwd（忘记密码） 是

示例代码☍

 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
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}/User/{appKey}/SendEmailCode"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
        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
import requests

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


data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}

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
package main

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

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

    var req *http.Request
    var err error


    data := {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/User/{appKey}/SendEmailCode", 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
const axios = require('axios');


const data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

const config = {
    method: 'post',
    url: '{server}/User/{appKey}/SendEmailCode',
    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
<?php

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


$data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

$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
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 = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/User/{appKey}/SendEmailCode", 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
require 'net/http'
require 'json'

uri = URI("{server}/User/{appKey}/SendEmailCode")
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 = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
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
const data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};

fetch("{server}/User/{appKey}/SendEmailCode", {
    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
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}/User/{appKey}/SendEmailCode")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
};
        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
import Foundation

let url = URL(string: "{server}/User/{appKey}/SendEmailCode")!
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 = {
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
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 错误信息 否

二次验证☍

接口说明

获取当前用户在指定应用下启用二次验证（2FA）所需的设置信息，主要包括二维码链接和手动密钥，用户可以将其录入在 Google Authenticator 等 TOTP 应用中，用于后续动态验证码验证。

基本信息☍

  • 接口名称：二次验证
  • 请求方式：GET
  • 请求路径：/User/{appKey}/TwoFactorAuth

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是

示例代码☍

 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}/User/{appKey}/TwoFactorAuth"))
            .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}/User/{appKey}/TwoFactorAuth"
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}/User/{appKey}/TwoFactorAuth", 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}/User/{appKey}/TwoFactorAuth',
    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}/User/{appKey}/TwoFactorAuth";
$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}/User/{appKey}/TwoFactorAuth");

            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}/User/{appKey}/TwoFactorAuth")
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}/User/{appKey}/TwoFactorAuth", {
    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}/User/{appKey}/TwoFactorAuth")
            .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}/User/{appKey}/TwoFactorAuth")!
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
{
    "code": 200          // 状态码,
    "data": {
    "account": "",
    "manualEntryKey": "",
    "qrCodeSetupImageUrl": ""
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data SetupCode - 否
error string 错误信息 否

数据结构☍

AppUserResetEmailRequest☍

1
2
3
4
{
    "email": ""          // 邮箱,
    "code": ""          // 邮箱验证码
}
字段名 类型 描述 是否必填
email string 邮箱 否
code string 邮箱验证码 是

AppUserResetPhoneRequest☍

1
2
3
4
{
    "phone": ""          // 手机号码,
    "code": ""          // 手机验证码
}
字段名 类型 描述 是否必填
phone string 手机号码 否
code string 手机验证码 是

AppUserResetPwdRequest☍

1
2
3
4
{
    "pwd": ""          // 新的密码,
    "oldpwd": ""          // 旧的密码
}
字段名 类型 描述 是否必填
pwd string 新的密码 是
oldpwd string 旧的密码 是

BooleanApiResponse☍

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

EmailSignInRequest☍

1
2
3
4
5
{
    "email": ""          // 用户邮箱地址,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填
}
字段名 类型 描述 是否必填
email string 用户邮箱地址 是
verifyCode string 验证码，长度为4到8位的数字 是
twoFactorCode string 双因素认证代码，如果启用双因素认证登录，则必填 否

EmailSignUpRequest☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
{
    "email": ""          // 用户邮箱地址,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "emailCode": ""          // 邮箱验证码,
    "phone": ""          // 手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入）,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
字段名 类型 描述 是否必填
email string 用户邮箱地址 是
pwd string 用户密码，长度为6到32个字符 是
emailCode string 邮箱验证码 否
phone string 手机号，必须为11位数字 否
phoneCode string 手机验证码（只有启用的手机验证码功能时，才需要传入） 否
nickName string 用户昵称 否
avatar string 用户头像URL 否
data string 自定义数据 否

PhoneSignInRequest☍

1
2
3
4
5
{
    "phone": ""          // 用户手机号,
    "verifyCode": ""          // 验证码，长度为4到8位的数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
字段名 类型 描述 是否必填
phone string 用户手机号 是
verifyCode string 验证码，长度为4到8位的数字 是
twoFactorCode string 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

PhoneSignUpRequest☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
{
    "phone": ""          // 用户手机号,
    "phoneCode": ""          // 手机验证码，长度为4到8位的数字,
    "pwd": ""          // 用户密码，长度为6到32个字符,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据
}
字段名 类型 描述 是否必填
phone string 用户手机号 是
phoneCode string 手机验证码，长度为4到8位的数字 是
pwd string 用户密码，长度为6到32个字符 是
email string 用户邮箱 否
emailCode string 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
nickName string 用户昵称 否
avatar string 用户头像URL 否
data string 自定义数据 否

SendEmailCodeRequest☍

1
2
3
4
{
    "email": ""          // 用户邮箱地址,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
字段名 类型 描述 是否必填
email string 用户邮箱地址 是
type string 用途。可选值：signup（注册）/forgetpwd（忘记密码） 是

SendSMSCodeRequest☍

1
2
3
4
{
    "phone": ""          // 用户手机号,
    "type": ""          // 用途。可选值：signup（注册）/forgetpwd（忘记密码）
}
字段名 类型 描述 是否必填
phone string 用户手机号 是
type string 用途。可选值：signup（注册）/forgetpwd（忘记密码） 是

SetupCode☍

1
2
3
4
5
{
    "account": "",
    "manualEntryKey": "",
    "qrCodeSetupImageUrl": ""
}
字段名 类型 描述 是否必填
account string - 否
manualEntryKey string - 否
qrCodeSetupImageUrl string - 否

SetupCodeApiResponse☍

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

SignInRequest☍

1
2
3
4
5
{
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
字段名 类型 描述 是否必填
userName string 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符 是
pwd string 用户密码，长度必须在6到50个字符之间，可以包含数字、大小写字母、下划线、连字符和特殊符号 是
twoFactorCode string 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

SignUpRequest☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
    "userName": ""          // 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符,
    "pwd": ""          // 登录密码，长度必须在6到32个字符之间，只能包含字母和数字,
    "nickName": ""          // 用户昵称，长度不能超过20个字符,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
字段名 类型 描述 是否必填
userName string 用户名，长度必须在6到32个字符之间，只能包含字母、数字、下划线和连字符 是
pwd string 登录密码，长度必须在6到32个字符之间，只能包含字母和数字 是
nickName string 用户昵称，长度不能超过20个字符 否
avatar string 用户头像URL 否
data string 自定义数据 否
email string 用户邮箱 否
emailCode string 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
phone string 用户手机号，必须为11位数字 否
phoneCode string 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字 否

TokenModel☍

1
2
3
4
5
{
    "access_token": "",
    "token_type": "",
    "expires_in": "0"
}
字段名 类型 描述 是否必填
access_token string - 否
token_type string - 否
expires_in integer - 否

TokenModelApiResponse☍

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

UnionIDSignInRequest☍

1
2
3
4
5
{
    "unionID": ""          // UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台，长度必须在1到20个字符之间，只能包含字母和数字,
    "twoFactorCode": ""          // 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字
}
字段名 类型 描述 是否必填
unionID string UnionID，长度必须在1到99个字符之间，只能包含字母、数字、下划线和连字符 是
platform string 平台，长度必须在1到20个字符之间，只能包含字母和数字 是
twoFactorCode string 双因素认证代码，如果启用双因素认证登录，则必填，长度必须为6个字符，只能包含数字 否

UnionIDSignUpRequest☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
{
    "userName": ""          // 登录账号，可空，只能包含字母、数字、下划线和连字符,
    "unionID": ""          // UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符,
    "platform": ""          // 平台标识，长度必须在1到20个字符之间，只能包含字母和数字,
    "pwd": ""          // 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号,
    "nickName": ""          // 用户昵称,
    "avatar": ""          // 用户头像URL,
    "data": ""          // 自定义数据,
    "email": ""          // 用户邮箱,
    "emailCode": ""          // 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字,
    "phone": ""          // 用户手机号，必须为11位数字,
    "phoneCode": ""          // 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字
}
字段名 类型 描述 是否必填
userName string 登录账号，可空，只能包含字母、数字、下划线和连字符 否
unionID string UnionID，长度不能超过99个字符，只能包含字母、数字、下划线和连字符 是
platform string 平台标识，长度必须在1到20个字符之间，只能包含字母和数字 是
pwd string 密码，长度必须在6到32个字符之间，只允许英文大小写、数字、标点符号 是
nickName string 用户昵称 否
avatar string 用户头像URL 否
data string 自定义数据 否
email string 用户邮箱 否
emailCode string 邮箱验证码（只有启用的邮箱验证码功能时，才需要传入），长度为4到8位的数字 否
phone string 用户手机号，必须为11位数字 否
phoneCode string 手机验证码（只有启用的手机验证码功能时，才需要传入），长度为4到8位的数字 否

UpdateProfileRequest☍

 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
{
    "avatar": ""          // 用户头像的链接或路径，长度不能超过255个字符,
    "data": ""          // 用户的其他数据，可以是序列化后的对象或JSON字符串,
    "nickName": ""          // 用户的昵称，长度不能超过50个字符,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介，长度不能超过500个字符,
    "gender": ""          // 性别，长度不能超过15个字符,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业，长度不能超过50个字符,
    "education": ""          // 学历，长度不能超过50个字符,
    "contact": ""          // 联系方式，长度不能超过255个字符,
    "languages": ""          // 语言，长度不能超过50个字符,
    "socialLinks": ""          // 社交网络链接，长度不能超过255个字符,
    "relationshipStatus": ""          // 婚姻状态，长度不能超过20个字符,
    "company": ""          // 公司，长度不能��过100个字符,
    "industry": ""          // 行业，长度不能超过50个字符,
    "companyPosition": ""          // 行业职位，长度不能超过50个字符,
    "privateSettings": ""          // 私密设置，长度不能超过500个字符,
    "enable2FAAuth": false          // 是否启用二步验证,
    "enableUserNameSignIn": false          // 是否启用账号登录,
    "enableEmailSignIn": false          // 是否启用邮箱登录,
    "enablePhoneSignIn": false          // 是否启用手机登录,
    "enableUnionIDSignIn": false          // 是否启用UnionID登录,
    "enableOAuth": false          // 是否启用OAuth2登录
}
字段名 类型 描述 是否必填
avatar string 用户头像的链接或路径，长度不能超过255个字符 否
data string 用户的其他数据，可以是序列化后的对象或JSON字符串 否
nickName string 用户的昵称，长度不能超过50个字符 否
interestTags string 兴趣标签 否
biography string 个人简介，长度不能超过500个字符 否
gender string 性别，长度不能超过15个字符 否
birthday string 生日 否
occupation string 职业，长度不能超过50个字符 否
education string 学历，长度不能超过50个字符 否
contact string 联系方式，长度不能超过255个字符 否
languages string 语言，长度不能超过50个字符 否
socialLinks string 社交网络链接，长度不能超过255个字符 否
relationshipStatus string 婚姻状态，长度不能超过20个字符 否
company string 公司，长度不能��过100个字符 否
industry string 行业，长度不能超过50个字符 否
companyPosition string 行业职位，长度不能超过50个字符 否
privateSettings string 私密设置，长度不能超过500个字符 否
enable2FAAuth boolean 是否启用二步验证 否
enableUserNameSignIn boolean 是否启用账号登录 否
enableEmailSignIn boolean 是否启用邮箱登录 否
enablePhoneSignIn boolean 是否启用手机登录 否
enableUnionIDSignIn boolean 是否启用UnionID登录 否
enableOAuth boolean 是否启用OAuth2登录 否

User☍

 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
{
    "id": "0"          // 用户唯一标识,
    "platform": ""          // 用户所在平台,
    "unionID": ""          // 用户所在平台的唯一标识,
    "nickName": ""          // 昵称,
    "avatar": ""          // 头像,
    "data": ""          // 其他数据,
    "userName": ""          // 用户名,
    "pwd": ""          // 用户密码,
    "email": ""          // 邮箱地址,
    "emailIsValid": false          // 邮箱已验证,
    "phone": ""          // 手机号码,
    "phoneIsValid": false          // 手机号码已验证,
    "relationChain": ""          // 关系链,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介,
    "gender": ""          // 性别,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业,
    "education": ""          // 学历,
    "contact": ""          // 联系方式,
    "languages": ""          // 语言,
    "socialLinks": ""          // 社交网络链接,
    "relationshipStatus": ""          // 婚姻状态,
    "company": ""          // 公司,
    "industry": ""          // 行业,
    "companyPosition": ""          // 行业职位,
    "privateSettings": ""          // 私密设置,
    "isLock": false          // 账户是否锁定,
    "lockUntil": ""          // 账户锁定截止时间,
    "enableUserNameSignIn": false          // 能使用用户名登录,
    "enableEmailSignIn": false          // 能使用邮箱登录,
    "enablePhoneSignIn": false          // 能使用电话号码登录,
    "enableUnionIDSignIn": false          // 能使用联合身份标识登录,
    "enableOAuth": false          // 能使用OAuth认证方式登录,
    "enable2FAAuth": false          // 启用双因素认证登录,
    "createDate": ""          // 创建时间,
    "lastUpdate": ""          // 最后更新时间
}
字段名 类型 描述 是否必填
id integer 用户唯一标识 否
platform string 用户所在平台 否
unionID string 用户所在平台的唯一标识 否
nickName string 昵称 否
avatar string 头像 否
data string 其他数据 否
userName string 用户名 否
pwd string 用户密码 否
email string 邮箱地址 否
emailIsValid boolean 邮箱已验证 否
phone string 手机号码 否
phoneIsValid boolean 手机号码已验证 否
relationChain string 关系链 否
interestTags string 兴趣标签 否
biography string 个人简介 否
gender string 性别 否
birthday string 生日 否
occupation string 职业 否
education string 学历 否
contact string 联系方式 否
languages string 语言 否
socialLinks string 社交网络链接 否
relationshipStatus string 婚姻状态 否
company string 公司 否
industry string 行业 否
companyPosition string 行业职位 否
privateSettings string 私密设置 否
isLock boolean 账户是否锁定 否
lockUntil string 账户锁定截止时间 否
enableUserNameSignIn boolean 能使用用户名登录 否
enableEmailSignIn boolean 能使用邮箱登录 否
enablePhoneSignIn boolean 能使用电话号码登录 否
enableUnionIDSignIn boolean 能使用联合身份标识登录 否
enableOAuth boolean 能使用OAuth认证方式登录 否
enable2FAAuth boolean 启用双因素认证登录 否
createDate string 创建时间 否
lastUpdate string 最后更新时间 否

UserCurrency☍

1
2
3
4
5
6
{
    "id": "0"          // 用户资产的唯一标识符。,
    "userID": "0"          // 与用户资产关联的用户ID。,
    "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
    "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
}
字段名 类型 描述 是否必填
id integer 用户资产的唯一标识符。 否
userID integer 与用户资产关联的用户ID。 否
currencyCode string 用户资产的货币代码，例如 'USD', 'CNY' 等。 否
balance integer 用户的账户余额，表示当前持有的货币数量。 否

UserProfileResult☍

 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
{
    "user": {
    "id": "0"          // 用户唯一标识,
    "platform": ""          // 用户所在平台,
    "unionID": ""          // 用户所在平台的唯一标识,
    "nickName": ""          // 昵称,
    "avatar": ""          // 头像,
    "data": ""          // 其他数据,
    "userName": ""          // 用户名,
    "pwd": ""          // 用户密码,
    "email": ""          // 邮箱地址,
    "emailIsValid": false          // 邮箱已验证,
    "phone": ""          // 手机号码,
    "phoneIsValid": false          // 手机号码已验证,
    "relationChain": ""          // 关系链,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介,
    "gender": ""          // 性别,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业,
    "education": ""          // 学历,
    "contact": ""          // 联系方式,
    "languages": ""          // 语言,
    "socialLinks": ""          // 社交网络链接,
    "relationshipStatus": ""          // 婚姻状态,
    "company": ""          // 公司,
    "industry": ""          // 行业,
    "companyPosition": ""          // 行业职位,
    "privateSettings": ""          // 私密设置,
    "isLock": false          // 账户是否锁定,
    "lockUntil": ""          // 账户锁定截止时间,
    "enableUserNameSignIn": false          // 能使用用户名登录,
    "enableEmailSignIn": false          // 能使用邮箱登录,
    "enablePhoneSignIn": false          // 能使用电话号码登录,
    "enableUnionIDSignIn": false          // 能使用联合身份标识登录,
    "enableOAuth": false          // 能使用OAuth认证方式登录,
    "enable2FAAuth": false          // 启用双因素认证登录,
    "createDate": ""          // 创建时间,
    "lastUpdate": ""          // 最后更新时间
},
    "currencies": [
      {
          "id": "0"          // 用户资产的唯一标识符。,
          "userID": "0"          // 与用户资产关联的用户ID。,
          "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
          "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
      }
    ],
    "role": ""
}
字段名 类型 描述 是否必填
user - - 否
currencies array - 否
role string - 否

UserProfileResultApiResponse☍

 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
{
    "code": 200          // 状态码,
    "data": {
    "user": {
    "id": "0"          // 用户唯一标识,
    "platform": ""          // 用户所在平台,
    "unionID": ""          // 用户所在平台的唯一标识,
    "nickName": ""          // 昵称,
    "avatar": ""          // 头像,
    "data": ""          // 其他数据,
    "userName": ""          // 用户名,
    "pwd": ""          // 用户密码,
    "email": ""          // 邮箱地址,
    "emailIsValid": false          // 邮箱已验证,
    "phone": ""          // 手机号码,
    "phoneIsValid": false          // 手机号码已验证,
    "relationChain": ""          // 关系链,
    "interestTags": ""          // 兴趣标签,
    "biography": ""          // 个人简介,
    "gender": ""          // 性别,
    "birthday": ""          // 生日,
    "occupation": ""          // 职业,
    "education": ""          // 学历,
    "contact": ""          // 联系方式,
    "languages": ""          // 语言,
    "socialLinks": ""          // 社交网络链接,
    "relationshipStatus": ""          // 婚姻状态,
    "company": ""          // 公司,
    "industry": ""          // 行业,
    "companyPosition": ""          // 行业职位,
    "privateSettings": ""          // 私密设置,
    "isLock": false          // 账户是否锁定,
    "lockUntil": ""          // 账户锁定截止时间,
    "enableUserNameSignIn": false          // 能使用用户名登录,
    "enableEmailSignIn": false          // 能使用邮箱登录,
    "enablePhoneSignIn": false          // 能使用电话号码登录,
    "enableUnionIDSignIn": false          // 能使用联合身份标识登录,
    "enableOAuth": false          // 能使用OAuth认证方式登录,
    "enable2FAAuth": false          // 启用双因素认证登录,
    "createDate": ""          // 创建时间,
    "lastUpdate": ""          // 最后更新时间
},
    "currencies": [
      {
          "id": "0"          // 用户资产的唯一标识符。,
          "userID": "0"          // 与用户资产关联的用户ID。,
          "currencyCode": ""          // 用户资产的货币代码，例如 'USD', 'CNY' 等。,
          "balance": "0"          // 用户的账户余额，表示当前持有的货币数量。
      }
    ],
    "role": ""
},
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

通用错误码☍

错误码 说明
200 成功