接口管理服务 JMan¶
简介¶
提供 Jarvis 用户管理（包括 SUser 及 BUser）、 应用管理和权限管理功能。
JMan 提供用户管理功能，给其它 JService 提供统一的用户管理中心，支持用户的添加、登录、校验和删除等功能，实现用户统一管理，注册一次即可使用所有 Jarvis 的服务；
JMan 提供应用管理功能，给其它 JService 提供统一的应用管理，app_token 是应用 ID，由用户管理，JMan 提供应用的创建及查询等；
JMan 提供权限管理功能，给其它 JService 提供一套简单的权限设置平台，支撑 Jarvis 所有服务的权限管理，用户可以按需开通。通过在内部控台中配置 BUser 的权限；
应用场景¶
服务权限管理¶
给服务提供一套简单的权限设置平台，服务以 Jarvis 规范 接入 Jarvis 体系，成为 SUser。通过 Jarvis 内部控台赋予 BUser 服务权限。
注：JService 请见“Jarvis服务规范”，SUser 申请流程请见“Jarvis账号申请流程”。
应用案例
账户权限管理服务（JAccount） 、文件管理服务（JFile） 、通用数据查询服务（JFetch） 、数据上报服务（Postbe） 和地理位置识别服务（LBS） 等 使用 JMan 权限管理功能来实现。
用户和应用管理¶
为 Jarvis 商户提供用户管理，注册一次即可使用 Jarvis 所有对外服务。并为对应的用户提供应用管理，包括应用创建、删除和编辑等功能。
应用案例
RealMe site 的用户和应用管理使用 JMan 功能，减少了 RealMe site 开发量，提高开发效率。
RealMe site 网址如下： https://realme.cloudpnr.com/。
常见问题¶
JMan 与 JAccount 的关系¶
JMan 与 JAccount 各拥有一套用户和权限管理系统，唯一不同的是两个系统所服务的用户群体的区别。
JMan 主要服务直接使用 Jarvis 系统所建立的应用，一般 Jarvis 的用户是一个商户而不是一个终端用户，商户在自己的程序里使用在 Jarvis 系统注册的用户登录 JMan，JMan 中的权限代表该用户在 Jarvis 系统中的权限。
而 JAccount 为商户提供了一套功能强大的用户及权限管理系统。商户创建的应用可以使用 JAccount 来维护自己的用户（终端用户）和用户的相关权限。
JMan 角色¶
JMan 中维护三种不同身份的用户，Jarvis Administrator、Service User 和 Jarvis User，下面分别对三种角色进行介绍。
Jarvis Administrator
Jarvis 的管理员，用于维护其他用户，仅在内部控台使用。他可以创建 Jarvis 用户，并维护所有 Jarvis 用户。
Service User（简称 SUser）
SUser 表示以 Jarvis 规范接入 Jarvis 的服务。成为 SUser，首先需要向接口管理服务 JMan 申请 username、password 和 skey。SUser 的申请流程见章节 “Jarvis账号申请流程”
Jarvis User（简称 BUser）
BUser 是使用 JService 的用户。在内部控台新增 BUser 用户，并管理 BUser 在 Jarvis 平台上所有服务的权限。申请流程见章节 “Jarvis账号申请流程”。
API 文档¶
请求地址¶
测试地址：http://192.168.16.158:10010
联调地址：http://192.168.16.248:10010
生产地址（阿里云）：https://jua.cloudpnr.com
生产地址（普天）：http://10.99.1.4
公共参数¶
公共请求参数
JMan 身份验证使用 HTTP 基本认证方式，将调用用户登录接口获取的 token 拼接在请求头中的 Authorization 字段， Authorization 的计算方式：base64encode(token 值) 。
例如：
GET /api/token HTTP/1.1
Host: http://192.168.16.158:10010
Authorization: Basic base64encode(token)
请将调用用户登录接口获取的 token 值进行 base64 编码后进行替换。
公共失败响应
返回码 |
返回信息 |
|---|---|
90100 |
获取参数失败 |
90101 |
获取 auth 信息失败 |
90102 |
没有找到对应用户 |
90103 |
skey 库中不存在对应用户 |
90104 |
没有查询到 Service 权限 |
90105 |
查询用户权限异常 |
90106 |
没有查询到用户权限 |
90107 |
用户权限更新异常 |
90108 |
操作用户权限数据异常 |
90109 |
skey 与调用者不匹配 |
90110 |
操作 Service 权限异常 |
90111 |
用户名不合法 |
90112 |
用户必须有 admin 权限 |
90113 |
用户必须有 Service 权限 |
自定义错误返回码
用户相关错误
包括创建、验证和删除用户时发生的错误。
返回码 |
返回信息 |
|---|---|
20001 |
user already exists - 创建用户时返回用户名已存在 |
20002 |
user name is illegal - 创建用户时用户名太长或太短，具体规则详见 JMan 创建用户章节 |
20003 |
user not exists - 删除用户时查询到用户不存在 |
20004 |
user password is illegal - 创建用户时密码错误 |
20005 |
user email is illegal - 创建用户时用户邮箱不符合规则 |
20011 |
create user write to db error - 创建用户时写库失败，状态码 |
20021 |
delete user write to db error - 删除用户时写库失败，状态码 |
20031 |
user id is illegal - 用户 ID 为空 |
20040 |
user must has admin privilege to do this - 当前用户没有 Jarvis 管理员权限 |
20041 |
user name is reserved - 创建用户时用户名已经被占用 |
app_token 相关错误
包括创建、查询和验证 app_token 时发生的错误。
返回码 |
返回信息 |
|---|---|
20201 |
unauthorized users - 用户未授权，用户名错误或者 app_token 错误 |
SUser 相关错误
只有 SUser 调用时有可能返回的错误。
返回码 |
返回信息 |
|---|---|
10014 |
skey and user doesnt match - 当前登录的 Service User 与提供的 Service Key 不匹配 |
10015 |
skey user not found - 提供的 Service Key 不存在 |
用户注册¶
-
j_main.j_api_man.create_user_by_service(version='v3')¶ HTTP Request
POST http://192.168.16.158:10010/api/v3/service/users请求参数
只有 Service User 可以使用
名称
类型
是否必须
限制
描述
user_name
String
是
64位
创建用户名
password
String
是
创建用户密码(明文传输)
email
String
是
50位
创建用户邮箱
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
响应参数
名称
类型
描述
user_name
String
用户名
失败响应
调用失败时状态码会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10011
用户名保留，不可以被创建，状态码 401
10012
用户密码不合法，状态码 400
10013
用户电子邮件不合法，状态码 400
10014
用户已经存在，状态码 400
10015
创建用户写入数据库错误，状态码 500
调用示例
shell
curl --user token: -X POST \ -F 'skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0' \ -F 'user_name=test_user' \ -F 'password=123' \ -F 'email="XX@XX.com"' \ -H env:test \ http://192.168.16.158:10010/api/v3/service/userspython
import requests url = "http://192.168.16.158:10010/api/v3/service/users" # v3 测试服务器 post_info = {'user_name': 'test_user', 'skey': 'skey-ba7a258d-3045-48e0-988d-600843e68ca0', 'password': '123', 'email': 'XX@XX.com'} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service/users"; // v3 测试服务器 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 EntityBuilder builder = EntityBuilder.create(); List<NameValuePair> parameters = new ArrayList<NameValuePair>(); parameters.add(new BasicNameValuePair("user_name", "test_user")); parameters.add(new BasicNameValuePair("skey", "skey-ba7a258d-3045-48e0-988d-600843e68ca0")); parameters.add(new BasicNameValuePair("password", "123")); parameters.add(new BasicNameValuePair("email", "XX@XX.com")); builder.setParameters(parameters); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); // 加入环境标识 method.addHeader("env", "test"); method.setEntity(reqEntity); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "user_name": "test_user" }
失败响应
400 { "message": "user already exists", "return_code": 10014 }
用户登录[BUser/SUser]¶
-
j_main.j_api_man.get_auth_token(version='v3')¶ 新用户注册时得到的用户名及密码获取认证 token。
HTTP Request
GET http://192.168.16.158:10010/api/v3/token请求参数
仅公共请求参数
响应参数
名称
类型
描述
token
String
用户授权 token
duration
Integer
token 有效期，单位为秒
token 作为唯一的身份验证方式，需要在大部分 Jarvis API 中传递。Jarvis 不推荐每调用一个 Jarvis API 服务时都去调用登录接口，以免造成不必要的时间消耗。保存 token 并维护 token 的有效性是我们推荐的方法。
失败响应
调用登录接口传递了错误的用户名或密码时，Jarvis 使用 HTTP 通用的状态码返回调用结果，例如：
401 Unauthorized Access调用示例
shell
curl --user jf_test:python -H env:test http://192.168.16.158:10010/api/v3/token
python
# 使用到 python 的 requests 包，可以执行 “pip install requests” 来安装 requests 软件包 import requests url = "http://192.168.16.158:10010/api/v3/token" # v3 测试服务器 username = "jf_test" # 测试用户用户名 password = "python" # 测试用户密码 response = requests.get(url, headers={'env':'test'}, auth=(username, password)) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/token"; // v3 测试服务器 String username = "jf_test"; // 测试用户用户名 String password = "python"; // 测试用户密码 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, userPassword)); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet httpget = new HttpGet(url); // 加入环境标识 httpget.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(httpget, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "duration": 600, "token": "eyJhbGciOiJIU_x1Mg" }
失败响应
401 Unauthorized Access
app_token 新增 (需用户登录)¶
-
j_main.j_api_man.apply_app_token_by_service(version='v3')¶ 申请 新增 app_token 时需要向 Jarvis 提供应用名称。
HTTP Request
POST http://192.168.16.158:10010/api/v3/service/app_tokens请求参数
只有 Service User 可以使用。
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
app_name
String
是
64位
应用名称
source
String
否
10位
来源
description
String
否
100位
描述
b_user_token
String
是
Jarvis User 的 token
响应参数
名称
类型
描述
app_name
String
应用名
app_token
Integer
应用唯一标识
app_key
Integer
应用密钥
失败响应
返回
4xx或5xx，并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到的错误码。返回码
返回信息
20104
app token already exists - app_token 已经存在
20101
app token write to db error - 添加 app_token 时写库失败，状态码 500
调用示例
shell
curl --user token: \ -X POST \ -F 'app_name=testapp' \ -F 'skey=skey-ba7a258d' \ -F 'b_user_token=b_user_token' \ -F 'source=ios' \ -F 'description=someapp' \ -H env:test \ http://192.168.16.158:10010/api/v3/service/app_token s
python
import requests url = "http://192.168.16.158:10010/api/v3/service/app_tokens" # v3 测试服务器 post_info = {'app_name': 'testapp', 'skey': 'skey-ba7a258d', 'b_user_token': 'b_user_token', 'source': 'ios', 'description': 'someapp',} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service/app_token s"; // v3 测试服务器 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 EntityBuilder builder = EntityBuilder.create(); List<NameValuePair> parameters = new ArrayList<NameValuePair>(); parameters.add(new BasicNameValuePair("app_name", "testapp")); parameters.add(new BasicNameValuePair("skey", "skey-ba7a258d")); parameters.add(new BasicNameValuePair("b_user_token", "b_user_token")); parameters.add(new BasicNameValuePair("source", "ios")); parameters.add(new BasicNameValuePair("description", "someapp")); builder.setParameters(parameters); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); // 加入环境标识 method.addHeader("env", "test"); method.setEntity(reqEntity); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "app_token": "app-ba7a258d-3045-48e0-988d-600843e68ca0" }
失败响应
400 { "message": "app token already exists", "return_code": 20104 }
app_token 新增 (免用户登录)¶
-
j_main.j_api_man.apply_b_user_app_token_by_service(version='v3')¶ 向 Service 申请 app_token，需要提供应用名称。
可在无需 Jarvis 用户登录的情况添加该用的 app-token。
HTTP Request
POST http://192.168.16.158:10010/api/v3/service/b-user-app-tokens请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
app_name
String
是
64位
应用名称
b_user_name
String
是
64位
需要申请 app_token 的 Jarvis User 的用户名
source
String
否
10位
来源
description
String
否
100位
描述
响应参数
名称
类型
描述
app_name
String
应用名
app_token
String
应用唯一标识
app_key
String
应用密钥
失败响应
会返回
4xx或5xx，并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
20104
app token already exists - app_token 已经存在
20101
app token write to db error - 添加 app_token 时写库失败，状态码 500
shell
curl --user token: \ -X POST \ -F 'app_name=testapp' \ -F 'skey=skey-ba7a258d' \ -F 'source=ios' \ -F 'description=someapp' \ -F 'b_user_name=testuser' \ -H env:test \ http://192.168.16.158:10010/api/v3/b-user-app-tokens
python
import requests url = "http://192.168.16.158:10010/api/v3/service/b-user-app-tokens" # v3 测试服务器 post_info = {'app_name': 'testapp', 'skey': 'skey-ba7a258d', 'source': 'ios', 'description': 'someapp', 'b_user_name': 'testuser'} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service/b-user-app-tokens"; // v3 测试服务器 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 EntityBuilder builder = EntityBuilder.create(); List<NameValuePair> parameters = new ArrayList<NameValuePair>(); parameters.add(new BasicNameValuePair("app_name", "testapp")); parameters.add(new BasicNameValuePair("skey", "skey-ba7a258d")); parameters.add(new BasicNameValuePair("source", "ios")); parameters.add(new BasicNameValuePair("description", "someapp")); parameters.add(new BasicNameValuePair("b_user_name", "testuser")); builder.setParameters(parameters); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); // 加入环境标识 method.addHeader("env", "test"); method.setEntity(reqEntity); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "app_token": "app-ba7a258d-3045-48e0-988d-600843e68ca0" }
失败响应
400 { "message": "app token already exists", "return_code": 20104 }
app_token 查询¶
-
j_main.j_api_man.query_app_token(version='v3')¶ 调用方可以通过该 API 查询到指定 app_name 的 app_token。
HTTP Request
GET http://192.168.16.158:10010/api/v3/app_tokens请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
b_app_token
String
否
Jarvis User 的应用 app_token
b_user_token
String
是
Jarvis User 的 token
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
响应参数
如果指定了 app_token ，返回如下。如没指定，返回如下列表
名称
类型
描述
app_name
String
应用名
app_token
String
应用唯一标识
app_key
String
应用密钥
source
String
应用开源
description
String
应用描述
失败响应
会返回
4xx或5xx，并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该API 的错误码。返回码
返回信息
20102
app token query db error - 查询 app_token 时读库失败，状态码 500
20105
app name not exists - 查询 app_token 时传递的 app_name 不存在，状态码 500
20106
app token apply username mismatch current username - app_token 与当前用户名不匹配
调用示例
shell
curl --user token: \ -H env:test \ http://192.168.16.158:10010/api/v3/app_token s?b_app_token=myapp_web&skey=skey-ba7a258d-s8u9gf67&b_user_token=eyJhbGciOiJIU_x1Mg
python
import requests url = "http://192.168.16.158:10010/api/v3/app_token s" # v3 测试服务器 # 拼接请求参数 url = url + "?app_name=" + "myapp_web" + "?skey=" + "skey-ba7a258d-s8u9gf67" + ",b_user_token=" + "test_token" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/app_token s"; // v3 测试服务器 // 拼接请求参数 url = url + "?app_name=" + "myapp_web" + "?skey=" + "skey-ba7a258d-s8u9gf67" + ",b_user_token=" + "test_token"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "app_token": "app-ba7a258d-3045-48e0-988d-600843e68ca0", "app_name": "app_name", "app_key": "4hsh45da634jh0", "source": "", "description": "", "create_date": "YYYY-mm-dd HH:MM:SS", }
失败响应
500 { "message": "app name not exists, app_name: myapp_web", "return_code": 20105 }
app_token 分页查询¶
-
j_main.j_api_man.query_app_tokens_list(version='v3')¶ 查询到指定 app_name 的 app_token。
HTTP Request
GET http://192.168.16.158:10010/api/v3/app_tokens/list请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
b_app_token
String
否
Jarvis User 的应用 app_token
b_user_name
String
否
64位
Jarvis User 的 user_name
b_app_name
String
否
64位
Jarvis User 的 app_name
skey
String
是
64位
Jarvis Service User 预先向 Jarvis Man 申请的 Service Key
page_num
String
否
查询当前页数
page_size
String
否
每页条数
响应参数
API 调用成功后返回根据条件查询出的 app_token 信息列表。
失败响应
返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。shell
curl --user token: \ -H env:test \ http://192.168.16.158:10010/api/v3/app_token s/list?b_app_token=myapp_web&skey=skey-ba7a258d-s8u9gf67&b_user_name=jf_test&page_num=1&page_size=10
python
import requests url = "http://192.168.16.158:10010/api/v3/app_token s/list" # v3 测试服务器 # 拼接请求参数 url = url + "?b_app_token=" + "myapp_web" + "&skey=" + "skey-ba7a258d-s8u9gf67" + "&b_user_name=" + "&jf_test" + "&page_num=" + "1" + "&page_size=" + "10" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/app_token s/list"; // v3 测试服务器 // 拼接请求参数 url = url + "?b_app_token=" + "myapp_web" + "&skey=" + "skey-ba7a258d-s8u9gf67" + "&b_user_name=" + "&jf_test" + "&page_num=" + "1" + "&page_size=" + "10"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { ["app_token": "app-ba7a258d-3045-48e0-988d-600843e68ca0", "app_name": "app_name", "app_key": "4hsh45da634jh0", "source": "", "description": "", "create_date": "YYYY-mm-dd HH:MM:SS"] }
失败响应
500 { "message": "app token not exists", "return_code": 20105 }
app_token 验证¶
-
j_main.j_api_man.query_b_user_app_token(version='v3')¶ Service 验证用户提供的 token 和 app_token 是否存在并有效。
HTTP Request
GET http://192.168.16.158:10010/api/v3/b-user-app-tokens请求参数
名称
类型
是否必须
限制
描述
b_user_token
String
是
Jarvis User 登录时获取的 token
b_app_token
String
是
Jarvis User 的 app_token
skey
String
是
64位
当前登录 Service User 的 skey
响应参数
名称
类型
描述
app_name
String
应用名
app_token
String
应用唯一标识
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
20110
app token db query error - 查询 app_token 时读库失败，状态码 500
20111
app token not found - 查询 app_token 不存在
shell
curl --user token: \ -H env:test \ http://192.168.16.158:10010/api/v3/b-user-app-tokens?token=eyJhbGciOiJIU_x1Mg&b_app_token=app-ba7a258d-3045-48e0-988d-600843e68ca0&skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0
python
import requests url = "http://192.168.16.158:10010/api/v3/b-user-app-tokens" # 测试服务器地址 # 请求参数 get_info = { 'b_user_token' : 'eyJhbGciOiJIU_x1Mg', 'b_app_token' : 'app-ba7a258d-3045-48e0-988d-600843e68ca0', 'skey' : 'skey-ba7a258d-3045-48e0-988d-600843e68ca0' } response = requests.get(url, headers={'env':'test'}, params=get_info, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/b-user-app-tokens"; // 测试服务器地址 // 拼接请求参数 url = url + "?b_user_token=" + "b_user_token"; url = url + "&b_app_token=" + "app-ba7a258d-3045-48e0-988d-600843e68ca0"; url = url + "&skey=" + "skey-ba7a258d-3045-48e0-988d-600843e68ca0"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "user_id": "xxx" }
失败响应
400 { "message": "app token not found", "return_code": 20111 }
服务 SKey 申请¶
-
j_main.j_api_man.apply_service_key(version='v3')¶ JMan 用 Service Key 来验证 Service 的真实性，只有 Service User 才可以申请和查询 Service Key，每个 Service 有且只有一个 Service Key。
本接口实现 申请 Service Key 功能，申请时需要向 JMan 提供系统名称。
HTTP Request
POST http://192.168.16.158:10010/api/v3/service-keys请求参数
名称
类型
是否必须
限制
描述
service_name
String
是
64位
系统名称
响应参数
名称
类型
描述
service_name
String
系统名称
skey
String
Service Key
失败响应
返回
4xx或5xx，并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10011
skey user had already applied skey - 当前用户已经申请过 Service Key
10012
skey write db error - 申请 Service Key 时写库失败，返回码 500
shell
curl --user token: \ -X POST \ -H env:test \ -F "service_name=jarvis_sky" \ http://192.168.16.158:10010/api/v3/service-keys
python
import requests url = "http://192.168.16.158:10010/api/v3/service-keys" # 测试服务器地址 post_info = {'service_name': 'jarvis_sky'} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service-keys"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("service_name", new StringBody("jarvis_sky", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "service_name": "jarvis_sky", "skey": "skey-ba7a258d-3045-48e0-988d-600843e68ca0" }
失败响应
400 { "message": "skey user had already applied skey, user_id: xxx", "return_code": 10011 }
服务 SKey 查询¶
-
j_main.j_api_man.query_service_key(version='v3')¶ Service User 可以通过调用该 API 查询到自己的 Service Key。
HTTP Request
GET http://192.168.16.158:10010/api/v3/service-keys请求参数
无。
响应参数
名称
类型
描述
skey
String
Service Key
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。返回码
返回信息
10311
查找 service key 时候，数据库错误
shell
curl --user token: \ -H env:test \ http://192.168.16.158:10010/api/v3/service-keys
import requests url = "http://192.168.16.158:10010/api/v3/service-keys" # 测试服务器地址 response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service-keys"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "skey": "skey-ba7a258d-3045-48e0-988d-600843e68ca0" }
失败响应
400 { "message": "skey user doesnt exists, user_id: xxx", "return_code": 10015 }
服务权限新增¶
-
j_main.j_api_man.add_service_permission(version='v3')¶ JMan 为 Service 提供了一套简单的权限管理，Service 在 JMan 中注册自己系统的权限表，JMan 只保存权限表，并不知道权限代表的含义， Jarvis User 在控台配置自己在某个 Service 中是否有某些权限。Service在处理用户请求时调用 JMan 查询到该用户的权限列表，并在 Service 的服务中来判断是否拥有权限继续处理用户的请求。
HTTP Request
POST http://192.168.16.158:10010/api/v3/service-permissions请求参数
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
p _id
String
是
权限 ID，不同的 Service 可以使用相同的 ID 值，此值只做为存储，具体含义需要各 Service 自行管理
p _note
String
是
64位
权限描述
响应参数
名称
类型
描述
p_id
String
权限 ID
service_user_id
String
Service User 的 ID
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10110
spermission already applied - 该权限已经存在
10111
spermission write db error - 添加权限定义时写库失败，状态码 500
shell
curl --user token: \ -X POST \ -H env:test \ -F 'skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0' \ -F 'p_id=010' \ -F 'p_note="permission to checkout"' \ http://192.168.16.158:10010/api/v3/service-permissions
python
import requests url = "http://192.168.16.158:10010/api/v3/service-permissions" # 测试服务器地址 post_info = {'skey': 'skey-ba7a258d-3045-48e0-988d-600843e68ca0', 'p_id': '010', 'p_note': 'permission to checkout'} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service-permissions"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-ba7a258d-3045-48e0-988d-600843e68ca0", ContentType.create("text/plain", "UTF-8"))); builder.addPart("p_id", new StringBody("010", ContentType.create("text/plain", "UTF-8"))); builder.addPart("p_note", new StringBody("permission to checkout", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "service_user_id": "xxx", "p_id": "010" }
失败响应
400 { "message": "spermission already applied, user_id: xxx", "return_code": 10110 }
服务权限查询¶
-
j_main.j_api_man.query_all_service_permission(version='v3')¶ Service User 使用该 API 查询当前 Service 的权限。
HTTP Request
GET http://192.168.16.158:10010/api/v3/service/service-permissions请求参数
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
p_id
String
否
权限 ID，查询该权限 ID 是否存在；如果该值为空则返回当前 Service 的所有权限 ID
service_name
String
否
64位
需要查询的 service_name
响应参数
如果调用时不提供
p_id则返回该 Service 的所有权限定义。名称
类型
描述
p_id
String
权限 ID
p_note
String
p_id 描述
service_user_id
String
Service User 的 ID
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10112
spermission db query error - 查询 p_id 时数据库错误，状态码
50010113
spermission userid or pid note found - 调用时提供的 p_id 不存在
shell
curl --user token: \ -X GET \ -H env:test \ http://192.168.16.158:10010/api/v3/service/service-permissions?skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0&p_id=010&service_name=test-service
python
import requests url = "http://192.168.16.158:10010/api/v3/service/service-permissions" # 测试服务器地址 # 拼接请求参数 url = url + "?skey=" + "skey-ba7a258d-3045-48e0-988d-600843e68ca0" url = url + "&p_id=" + "010" url = url + "&service_name=" + "test-service" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service/service-permissions"; // 测试服务器地址 // 拼接请求参数 url = url + "?skey=" + "skey-ba7a258d-3045-48e0-988d-600843e68ca0"; url = url + "&p_id=" + "010"; url = url + "&service_name=" + "test-service"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "service_user_id": "xxx", "p_id": "010", "p_note": "permission to checkout." } 如果调用时不传 ``p_id`` 则会返回当前 Service 的所有权限。200 { "service_user_id": "xxx", "permissions": [ {"p_id": "010", "p_note": "permission to checkout."}, {"p_id": "011", "p_note": "permission to submit"} ] }
失败响应
404 { "message": "spermission user_id or p_id note found, user_id: xxx, p_id: 010", "return_code": 10113 }
服务权限删除¶
-
j_main.j_api_man.delete_service_permission(version='v3')¶ Service User 使用该 API 删除当前 Service 的权限。
HTTP Request
DELETE http://192.168.16.158:10010/api/v3/service-permissions请求参数
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
p_id
String
是
要删除的权限 ID
响应参数
名称
类型
描述
p_id
String
权限 ID
service_user_id
String
Service User 的 ID
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10111
spermission write db error - 删除权限时写数据库失败，错误代码
50010113
spermission user_id or p_id note found - 调用时提供的 p_id 不存在
shell
curl --user token: \ -X DELETE \ -H env:test \ -F 'skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0' \ -F 'p_id=010' \ http://192.168.16.158:10010/api/v3/service-permissions
python
import requests url = "http://192.168.16.158:10010/api/v3/service-permissions" # 测试服务器地址 post_info = {'skey': 'skey-ba7a258d-3045-48e0-988d-600843e68ca0', 'p_id': '010'} # 拼接请求参数 response = requests.delete(url, headers={'env':'test'}, data=post_info, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpDelete; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/service-permissions"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-ba7a258d-3045-48e0-988d-600843e68ca0", ContentType.create("text/plain", "UTF-8"))); builder.addPart("p_id", new StringBody("010", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpDelete method = new HttpDelete(url); // 加入环境标识 method.addHeader("env", "test"); method.setEntity(reqEntity); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
204 { "service_user_id": "xxx", "p_id": "010" }
失败响应
400 { "message": "spermission write db error, user_id: xxx, p_id: 010", "return_code": 10113 }
服务名查询¶
-
j_main.j_api_man.get_service_user_list(version='v3')¶ 服务名查询
HTTP Request
GET http://192.168.16.158:10010/api/v3/users/service-list请求参数
名称
类型
是否必须
限制
描述
skey
String
是
64位
skey
响应参数
API 调用成功后返回 Service User名列表。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。该接口只返回了公共返回错误码。shell
curl --user token: -X GET -H env:test http://192.168.16.158:10010/api/v3/users/service-list?skey=skey-XXXXXXXXpython
import requests url = "http://192.168.16.158:10010/api/v3/users/service-list" # 测试服务器地址 # 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/users/service-list"; // 测试服务器地址 // 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "result_list": [], "has_next": "true", "total": "20" }
失败响应
404 { "message": "opening service info query db not found", "return_code": 10513 }
BUser 验证和权限查询¶
-
j_main.j_api_man.query_b_user_permission_without_auth(version='v3')¶ Service User 使用该 API 查询 Jarvis User 的权限。并且包含了验签功能,可以验证 Jarvis User 的合法性。验证通过后会将 Jarvis User 的权限列表返回给 Service 。
HTTP Request
GET http://192.168.16.158:10010/api/v3/b-user-permissions请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
b_app_token
String
是
Jarvis User 的 app_token
signature
String
是
Jarvis User 调用 Jarvis 服务时生成的签名
plain_text
String
是
2位
Service User 的根据自己接口定义的明文拼接规则，生成的明文串
status
String
是
是否是有效权限。00:无效,01:有效,02:强制关闭
响应参数
API 调用成功后返回用户在该 Service 中拥有的权限列表。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
10213
permission not found - 用户没有任何权限
10512
incorrect signature - 签名不正确
shell
curl --user token: \ -X GET \ -H env:test \ http://192.168.16.158:10010/api/v3/b-user-permissions?skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0&b_app_token=app-ba7a258d-3045-48e0-988d-600843e68ca0&plain_text=123&signature=75fcfdea864894744f006698ced85a976419b04b507b1e391842617b1aaafae0&status=01
python
import requests url = "http://192.168.16.158:10010/api/v3/b-user-permissions" # 测试服务器地址 # 拼接请求参数 url = url + "?skey=" + "skey-ba7a258d-3045-48e0-988d-600843e68ca0" url = url + "&b_app_token=" + "app-ba7a258d-3045-48e0-988d-600843e68ca0" url = url + "&plain_text=" + "123" url = url + "&signature=" + "75fcfdea864894744f006698ced85a976419b04b507b1e391842617b1aaafae0" url = url + "&status=" + "01" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/b-user-permissions"; // 测试服务器地址 // 拼接请求参数 url = url + "?skey=" + "skey-ba7a258d-3045-48e0-988d-600843e68ca0" url = url + "&b_app_token=" + "app-ba7a258d-3045-48e0-988d-600843e68ca0" url = url + "&plain_text=" + "123" url = url + "&signature=" + "75fcfdea864894744f006698ced85a976419b04b507b1e391842617b1aaafae0" url = url + "&status=" + "01" // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "p_id_list": [ "010", "011" ], "service_user_id": "xxx", "service_user_name": "jarvis_sky", "user_id": "xxx" }
失败响应
404 { "message": "permission not found, user_id: xxx", "return_code": 10213 }
BUser 权限修改¶
-
j_main.j_api_man.update_b_user_permission(version='v3')¶ Service User 使用该 API 修改 Jarvis User 的权限。该接口需要验证 Service User 是否合法，验证通过后会将根据参数修改 Jarvis User 的权限状态。
HTTP Request
PUT http://192.168.16.158:10010/api/v3/b-user-permissions请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
b_user_name
String
是
Jarvis User 的 user_name
service_name
String
是
64位
Service User 的 user_name
p_id_list
String
否
pid 列表，以空格隔开
status
String
是
是否是有效权限。00:无效,01:有效,02:强制关闭
响应参数
API 调用成功后返回已经更新状态的权限列表。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节， 使用下表可以查询到该 API 的错误码。返回码
返回信息
90114
request {param_name} is illegal - 请求参数不合法
90107
upermission update error - 更新权限失败
shell
curl --user token: \ -X PUT \ -H env:test \ -F 'skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0' \ -F 'b_user_name=test-user' \ -F 'service_name=test-service' \ -F 'p_id_list="100 101"' \ -F 'status=00' \ http://192.168.16.158:10010/api/v3/b-user-permissions
python
import requests url = "http://192.168.16.158:10010/api/v3/b-user-permissions" # 测试服务器地址 post_info = {'skey': 'skey-ba7a258d-3045-48e0-988d-600843e68ca0', 'b_user_name': 'test-user', 'service_name': 'test-service', 'p_id_list': '100 101', 'status': '00'} # 拼接请求参数 response = requests.put(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/b-user-permissions"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-ba7a258d-3045-48e0-988d-600843e68ca0", ContentType.create("text/plain", "UTF-8"))); builder.addPart("b_user_name", new StringBody("test-user", ContentType.create("text/plain", "UTF-8"))); builder.addPart("service_name", new StringBody("test-service", ContentType.create("text/plain", "UTF-8"))); builder.addPart("p_id_list", new StringBody("100 101", ContentType.create("text/plain", "UTF-8"))); builder.addPart("status", new StringBody("00", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPut method = new HttpPut(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "service_user_id": "xxx", "p_id": "010" }
失败响应
500 { "message": "upermission update error", "return_code": 90107 }
BUser 权限新增¶
-
j_main.j_api_man.add_b_user_permission(version='v3')¶ Service User 使用该 API 新增 Jarvis User 的权限。该接口需要验证 Service User 是否合法，验证通过后会将根据参数为指定 Jarvis User 添加对应权限。
HTTP Request
POST http://192.168.16.158:10010/api/v3/b-user-permissions请求参数
只有 Service User可以使用。
名称
类型
是否必须
限制
描述
skey
String
是
64位
Service User 预先向 JMan 申请的 Service Key
b_user_name
String
是
Jarvis User 的 user_name
service_name
String
是
64位
Service User 的 user_name
p_id_list
String
是
pid 列表,以空格隔开
status
String
否
是否是有效权限。00:无效,01:有效,02:强制关闭
响应参数
API 调用成功后返回已经更新状态的权限列表。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节，使用下表可以查询到该 API 的错误码。返回码
返回信息
90114
request {param_name} is illegal - 请求参数不合法
90107
upermission update error - 更新权限失败
shell
curl --user token: \ -X POST \ -H env:test \ -F 'skey=skey-ba7a258d-3045-48e0-988d-600843e68ca0' \ -F 'b_user_name=test-user' \ -F 'service_name=test-service' \ -F 'p_id_list="100 101"' \ -F 'status=00' \ http://192.168.16.158:10010/api/v3/b-user-permissions
python
import requests url = "http://192.168.16.158:10010/api/v3/b-user-permissions" # 测试服务器地址 post_info = {'skey': 'skey-ba7a258d-3045-48e0-988d-600843e68ca0', 'b_user_name': 'test-user', 'service_name': 'test-service', 'p_id_list': '100 101', 'status': '00'} # 拼接请求参数 response = requests.post(url, data=post_info, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/b-user-permissions"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-ba7a258d-3045-48e0-988d-600843e68ca0", ContentType.create("text/plain", "UTF-8"))); builder.addPart("b_user_name", new StringBody("test-user", ContentType.create("text/plain", "UTF-8"))); builder.addPart("service_name", new StringBody("test-service", ContentType.create("text/plain", "UTF-8"))); builder.addPart("p_id_list", new StringBody("100 101", ContentType.create("text/plain", "UTF-8"))); builder.addPart("status", new StringBody("00", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "service_user_id": "xxx", "p_id": "010" }
失败响应
500 { "message": "upermission update error", "return_code": 90107 }
BUser 扩展信息查询¶
-
j_main.j_api_man.query_user_extension_info(version='v3')¶ Service User 使用该 API 查询某个 Jarvis User 的扩展信息。
HTTP Request
GET http://192.168.16.158:10010/api/v3/user-extension-info请求参数
名称
类型
是否必须
限制
描述
user_name
String
是
64位
用户名
skey
String
是
64位
skey
响应参数
API 调用成功后返回对应的用户拓展信息。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。返回码
返回信息
10411
USER_EXTENSION 查询失败
10413
USER_EXTENSION 查询没有找到记录
shell
curl --user token: \ -X GET \ -H env:test \ http://192.168.16.158:10010/api/v3/user-extension-info?user_name=jf_test&skey=skey-XXXXXXXX
python
import requests url = "http://192.168.16.158:10010/api/v3/user-extension-info" # 测试服务器地址 # 拼接请求参数 url = url + "?user_name=" + "jf_test" url = url + "&skey=" + "skey-XXXXXXXX" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/user-extension-info"; // 测试服务器地址 // 拼接请求参数 url = url + "?user_name=" + "jf_test"; url = url + "&skey=" + "skey-XXXXXXXX"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "user_name": "jf_test", "full_name": "xxx", "simple_name": "xxx", "legal_name": "xxx", ...... }失败响应
400 { "message": "user extension info query db not found", "return_code": 10413 }
BUser 扩展信息新增/修改¶
-
j_main.j_api_man.replace_user_extension_info(version='v3')¶ Service User 使用该 API 新增某个 Jarvis User 的扩展信息。
HTTP Request
POST http://192.168.16.158:10010/api/v3/user-extension-info请求参数
名称
类型
是否必须
限制
描述
user_name
String
是
64位
用户名
skey
String
是
64位
skey
full_name
String
否
80位
企业全称
simple_name
String
否
50位
企业简称
comp_license_type
String
否
8位
企业执照类型
business_code
String
否
100位
营业执照注册号
business_org_id
String
否
20位
工商机构号
business_code_time
date
否
工商登记号有效期
business_code_term
int
否
工商登记号是否永久有效
institution_code
String
否
9位
组织机构代码
institution_code_time
String
否
组织机构代码有效期
institution_code_term
int
否
组织机构代码是否永久有效
tax_code
String
否
30位
税务登记证号
tax_code_time
String
否
税务登记号有效期
tax_code_term
String
否
税务登记号是否永久有效
business_url
String
否
50位
营业执照扫描件
business_scope
String
否
100位
经营范围
comp_reg_address
String
否
100位
企业注册地址
legal_name
String
否
20位
法定代表人姓名
legal_cert_type
String
否
8位
法人证件类型
legal_cert_id
String
否
20位
法人证件号码
legal_mobile
String
否
11位
法定代表人手机号
contact_mobile
String
否
11位
联系人手机号
social_credit_code
String
否
18位
统一社会信用代码
license_start_date
String
否
证照起始日期
license_end_date
String
否
证照结束日期
comp_business_address
String
否
100位
企业经营地址
comp_fixed_telephone
String
否
15位
企业固定电话
controlling_shareholder
String
否
100位
控股股东
contact_name
String
否
50位
企业联系人姓名
contact_email
String
否
50位
联系人邮箱
comp_type
String
否
8位
企业类型
industry
String
否
行业 1:金融,2:电商,3:医疗健康,4:教育,5:文化娱乐,6:物流,7:汽车交通,8:其他
scale
String
否
规模 1:50人以下,2:50-100人,3:100-200人,4:200-500人,5:500人以上
email
String
否
50位
邮箱
mobile
String
否
11位
手机号
verify_status
String
否
邮箱验证状态 1:已验证,0:未验证
verify_time
String
否
邮箱验证时间
comp_cert
String
否
企业认证 0:未认证,1:已认证,2:待认证,3:认证失败
comp_cert_mark
String
否
100位
企业认证备注
响应参数
API 调用成功后修改对应记录，并返回成功代码。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。返回码
返回信息
10412
USER_EXTENSION 增加或更新失败
shell
curl --user token: \ -X POST \ -H env:test \ -F 'skey=skey-XXXXXXXX' \ -F 'user_name=jf_test' \ -F 'full_name=XXXXXXX' \ http://192.168.16.158:10010/api/v3/user-extension-info
python
import requests url = "http://192.168.16.158:10010/api/v3/user-extension-info" # 测试服务器地址 post_info = {'skey': 'skey-XXXXXXXX', 'user_name': 'jf_test', 'full_name': 'XXXXXXX'} # 拼接请求参数 response = requests.post(url, headers={'env':'test'}, data=post_info, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/user-extension-info"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); post_info = {'skey': 'skey-XXXXXXXX', 'user_name': 'jf_test', 'full_name': 'XXXXXXX'} // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-XXXXXXXX", ContentType.create("text/plain", "UTF-8"))); builder.addPart("user_name", new StringBody("jf_test", ContentType.create("text/plain", "UTF-8"))); builder.addPart("full_name", new StringBody("XXXXXXX", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);成功响应
201 { "user_name": "jf_test" }
失败响应
500 { "message": "user extension info write db error", "return_code": 10412 }
BUser 扩展信息列表查询¶
-
j_main.j_api_man.query_user_extension_info_list(version='v3')¶ Service User 使用该 API 查询 Jarvis User 的扩展信息列表。
HTTP Request
GET http://192.168.16.158:10010/api/v3/user-extension-info/list请求参数
名称
类型
是否必须
限制
描述
user_name
String
否
64位
用户名
skey
String
是
64位
skey
comp_cert
String
否
企业认证状态
simple_name
String
否
50位
企业简称
mobile
String
否
11位
手机号
page_num
String
否
查询当前页数
page_size
String
否
每页条数
响应参数
API 调用成功后返回对应的用户拓展信息：注册日期, 用户名, 绑定手机, 企业简称, 行业, 规模, 企业认证状态。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。返回码
返回信息
10511
user_opening_service_info 查询失败
10513
user_opening_service_info 没有找到记录
shell
curl --user token: \ -X GET \ -H env:test \ http://192.168.16.158:10010/api/v3/user-extension-info/list?skey=skey-XXXXXXXX
python
import requests url = "http://192.168.16.158:10010/api/v3/user-extension-info/list" # 测试服务器地址 # 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/api/v3/user-extension-info/list"; // 测试服务器地址 // 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "query_user_extension_info_list": [], "has_next": true, "total": "20" }
失败响应
404 { "message": "user extension info query db not found", "return_code": 10413 }
BUser 服务开通信息新增/修改¶
-
j_main.j_api_man.replace_user_opening_service_info(version='v3')¶ Service User 使用该 API 新增某个 Jarvis User 的服务开通信息。
HTTP Request
POST http://192.168.16.158:10010/api/v3/user-opening-service-info请求参数
名称
类型
是否必须
限制
描述
user_name
String
是
64位
用户名
skey
String
否
64位
skey
service_name
String
否
64位
服务名
service_cert
String
否
服务开通状态
author_protocol_url
String
否
100位
代办授权书
protocol_url
String
否
100位
服务协议
service_cert_mark
String
否
20位
服务开通备注
响应参数
API 调用成功后修改对应记录，并返回成功代码。
失败响应
会返回
4xx或5xx,并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。返回码
返回信息
10512
user_opening_service_info 增加或更新失败
shell
curl --user token: \ -X POST \ -H env:test \ -F 'skey=skey-XXXXXXXX' \ -F 'user_name=jf_test' http://192.168.16.158:10010/api/v3/user-opening-service-info
python
import requests url = "http://192.168.16.158:10010/api/v3/user-opening-service-info" # 测试服务器地址 post_info = {'skey': 'skey-XXXXXXXX', 'user_name': 'jf_test'} # 拼接请求参数 response = requests.post(url, headers={'env':'test'}, data=post_info, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import java.util.ArrayList; import java.util.List; import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.entity.EntityBuilder; import org.apache.http.NameValuePair; import org.apache.http.message.BasicNameValuePair; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/user-opening-service-info"; // 测试服务器地址 // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 写入请求参数 MultipartEntityBuilder builder = MultipartEntityBuilder.create(); builder.addPart("skey", new StringBody("skey-XXXXXXXX", ContentType.create("text/plain", "UTF-8"))); builder.addPart("user_name", new StringBody("jf_test", ContentType.create("text/plain", "UTF-8"))); HttpEntity reqEntity = builder.build(); // 建立请求 HttpPost method = new HttpPost(url); method.setEntity(reqEntity); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
201 { "user_name": "jf_test" }
失败响应
500 { "message": "opening service info write db error", "return_code": 10501 }
BUser 服务开通信息查询¶
-
j_main.j_api_man.query_user_opening_service_info_list(version='v3')¶ Service User 使用该 API 获取某个 Jarvis User 的服务开通信息。
HTTP Request
GET http://192.168.16.158:10010/api/v3/user-opening-service-info/list请求参数
名称
类型
是否必须
限制
描述
user_name
String
否
64位
用户名
skey
String
是
64位
skey
service_cert
String
否
企业认证状态
service_name
String
否
64位
服务名
simple_name
String
否
50位
企业简称
comp_cert
String
否
企业认证状态
page_num
String
否
查询当前页数
page_size
String
否
每页条数
响应参数
API 调用成功后返回对应的用户拓展信息：注册日期, 用户名, 绑定手机, 企业简称, 企业认证状态， 服务状态， 代办授权书， 服务协议。
失败响应
添加权限的 API 调用失败时状态码会返回
4xx或5xx。并在响应体中提供一段 JSON 格式的详细错误信息，通用的错误可以参考错误代码章节。shell
curl --user token: \ -X GET \ -H env:test http://192.168.16.158:10010/api/v3/user-opening-service-info/list?skey=skey-XXXXXXXX
python
import requests url = "http://192.168.16.158:10010/api/v3/user-opening-service-info/list" # 测试服务器地址 # 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX" response = requests.get(url, headers={'env':'test'}, auth=(token, '')) # 发送请求 print(response.status_code) # 打印状态码 print(response.text) # 打印返回内容
java
// 导入网络请求包 import org.apache.http.client.CredentialsProvider; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.HttpEntity; import org.apache.http.util.EntityUtils; String url = "http://192.168.16.158:10010/api/v3/user-opening-service-info/list"; // 测试服务器地址 // 拼接请求参数 url = url + "?skey=" + "skey-XXXXXXXX"; // HTTP 基本认证 CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(token, "")); HttpClientContext context = HttpClientContext.create(); context.setCredentialsProvider(credsProvider); // 建立请求 HttpGet method = new HttpGet(url); // 加入环境标识 method.addHeader("env", "test"); httpClient = HttpClientBuilder.create().build(); // 接收返回 response = httpClient.execute(method, context); // 打印状态码 System.out.println(response.getStatusLine().getStatusCode()); // 打印返回内容 HttpEntity entity = response.getEntity(); String jsonStr = EntityUtils.toString(entity); System.out.println(jsonStr);
成功响应
200 { "result_list": [], "has_next": "true", "total": "20" }
失败响应
404 { "message": "opening service info query db not found", "return_code": 10513 }
